TypeScript 学习笔记(七)：条件类型

条件类型

TS中的条件类型就是在类型中添加条件分支，以支持更加灵活的泛型，满足更多的使用场景。内置条件类型是TS内部封装好的一些类型处理，使用起来更加便利。

一、基本用法

当T类型可以赋值给U类型时，则返回X类型，否则返回Y类型。

T extends U ? X : Y
  • T U X Y 四个是占位符，分别表示四种类型；
  • T extends U表示T类型能被赋值给U类型，这里还涉及到TS类型兼容性。

这个表达式的意思是，如果 T 可以赋值给 U 类型，则是 X 类型，否则是 Y 类型。来看个实际例子：

T的具体类型返回不同类型的字符串，也就是字面量类型

type TypeName<T> =T extends string ? "string" :T extends number ? "number" :T extends boolean ? "boolean" :T extends undefined ? "undefined" :T extends Function ? "function" :"object";type A = TypeName<'1'> //"string"
type B = TypeName<1> //"number"
type C = TypeName<true> //"blolean"
type D = TypeName<undefined> //"undefined"
type E = TypeName<()=>void> //"function"
type F = TypeName<{}> //"object "

T为联合类型时 :

type G = TypeName<'1'｜ 1 ｜ true> // "string" | "number" | "boolean"
type H = TypeName<()=>void | {}> // "function" | "object"

根据类型参数判断返回类型：

二、分布式条件类型

什么样的条件类型称为分布式条件类型呢？

答案是：条件类型里待检查的类型必须是裸类型（naked type parameter）

1. 什么类型是裸类型？

裸类型是指类型参数没有被包装在其他类型里,比如没有被数组、元组、函数、Promise等等包裹，简而言之裸类型就是未经过任何其他类型修饰或包装的类型。

当分布式条件类型中被检查类型为联合类型，则在运算过程中分解多个分支 。

type typeName<T> = T extends number ? "X" : "Y" ;
type H = typeName<string | number> // "X" | "Y"//上面typeName在计算类型时，会分解为如下：
type H =  string extends number ? "X" : "Y" ｜ number extends number ? "X" : "Y" 
= "X" | "Y"

// 裸类型参数,没有被任何其他类型包裹，即T
type NakedType<T> = T extends boolean ? "YES" : "NO"
// 类型参数被包裹的在元组内，即[T]
type WrappedType<T> = [T] extends [boolean] ? "YES" : "NO";

2. 分布式如何理解？

分布式条件类型在实例化时会自动分发成联合类型

什么意思呢？

T extends U ? X : Y使用类型参数A | B | C 实例化 T 解析为 (A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y)

结合 乘法分配律 理解一下！

接下来结合具体实例我们来看一下分布式条件类型 与 不含有分布式特性的条件类型

  // 裸类型参数,没有被任何其他类型包裹，即Ttype NakedType<T> = T extends boolean ? 'YES' : 'NO';// 类型参数被包裹的在元组内，即[T]type WrappedType<T> = [T] extends [boolean] ? 'YES' : 'NO';// 含有分布式特性的，待检查类型必须为”裸类型“type Distributed = NakedType<number | boolean>; //  = NakedType<number> | NakedType<boolean> =  "NO" | "YES"（结合一下乘法分配律便于理解与记忆哦~）// 不含有分布式特性的，待检查的类型为包装或修饰过的类型type NotDistributed = WrappedType<number | boolean>; // "NO"

搞明白了分布式条件类型，我们编写这样一个类型工具 NonNullable ，即从类型 T 中排除 null 和 undefined ，我们期待的结果如下：

type a = NonNullable<string | number | undefined | null> // 得到type a = string | number

借助条件类型可以很容易写出来：

type NonNullable<T> = T extends null | undefined ? never : T

注意：never 类型表示不会是任何值，即什么都没有

三、非分布式条件类型

当T被数组、元组、Promise等包裹时，则运算过程中不会分解成多个分支，则该条件类型为非分布式条件类型。

type WrappedTuple<T> = [T] extends [boolean] ? "X" : "Y";
type WrappedArray<T> = T[] extends boolean[] ? "X" : "Y";
type WrappedPromise<T> = Promise<T> extends Promise<boolean> ? "X" : "Y";
type G = WrappedTuple<string | boolean>; // "Y"
type K = WrappedArray<string | boolean>; // "Y"
type L = WrappedPromise<string | boolean>; // "Y"

解析：

//由于计算数据时不会分解成多个分支// [T] extends [boolean]
//WrappedTuple<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型//T[] extends boolean[]
//WrappedArray<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型//Promise<T> extends Promise<boolean>
//WrappedPromise<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型

四、结合泛型使用

1. 过滤出公共类型

在联合类型T中过滤出联合类型U中的成员，过滤出来的成员则组成新的类型。下面例子中，如果类型T为类型U的子类型，则返回类型T，否则返回never

type Filter<T, U> = T extends U ? T : never;
type B = Filter<"a" | "b" | "c", "a" | "c" | "d"> ; // "a" | "c"

2. 类型删除

在联合类型T中删除联合类型U中的成员，T类型中的剩余成员则组成新的类型。下面例子中，如果类型T为类型U的子类型，则返回never，否则返回类型T

type Diff<T, U> = T extends U ? never : T;
type A = Diff<"a" | "b" | "c", "a" | "c" | "d">;  // "b"

五、结合 infer 关键字

1. 根据类型参数判断返回类型

  1. 案例一：

条件类型提供一个infer关键字用来推断类型，我们先来看个例子。我们想定义一个条件类型，如果传入的类型是一个数组，则返回它元素的类型；如果是一个普通类型，则直接返回这个类型。来看下不使用 infer 的话，怎么写：

type Type<T> = T extends any[] ? T[number] : T;
type test = Type<string[]>; // test的类型为string
type test2 = Type<string>; // test2的类型为string

这个例子中，如果传入 Type 的是一个数组类型，那么返回的类型为T[number]，也就是该数组的元素类型，如果不是数组，则直接返回这个类型。这里我们是自己通过索引访问类型T[number]来获取类型的，如果使用 infer 关键字则无需自己手动获取，我们来看下怎么使用 infer：

type Type<T> = T extends Array<infer U> ? U : T;
type test = Type<string[]>; // test的类型为string
type test2 = Type<string>; // test2的类型为string

这里 infer 能够推断出 U 的类型，并且供后面使用，你可以理解为这里定义了一个变量 U 来接收数组元素的类型。

  1. 案例二：
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;const foo = (): string => {return "hello";
}const bar = (): number => {return 42;
}const str: ReturnType<typeof foo> = "hello"; // string
const num: ReturnType<typeof bar> = 42; // number

在这个例子中，我们定义了一个 ReturnType 类型，它接受一个泛型类型参数 T。这个类型参数代表一个函数类型，我们通过 T extends (…args: any[]) => infer R 这个条件语句来判断 T 是否是一个函数类型，并提取其返回值类型 R。如果 T 是一个函数类型，则返回 R 类型，否则返回 never 类型。

然后，我们定义了两个函数 foo 和 bar，分别返回字符串和数字。我们使用 typeof 操作符来获取这两个函数的类型，并通过 ReturnType 和 ReturnType 来获取它们的返回类型。

最后，我们声明了两个变量 str 和 num，并分别将它们声明为 ReturnType 和 ReturnType 类型。这样就可以根据不同的函数类型来确定返回类型。

  1. 案例三：
 type IsOptional<T> = T extends { [k: string]: infer U } ? undefined extends U ? true : false : never;interface Person {name: string;age?: number;
}const person1: Person = { name: "Alice" };
const person2: Person = { name: "Bob", age: 30 };const isOptional1: IsOptional<typeof person1> = true; // true
const isOptional2: IsOptional<typeof person2> = true; // false

在这个例子中，我们定义了一个 IsOptional 类型，它接受一个泛型类型参数 T。这个类型参数代表一个对象类型，我们通过 T extends { [k: string]: infer U } 这个条件语句来判断 T 是否是一个对象类型，并提取其属性类型 U。然后，我们再使用 undefined extends U ? true : false 来判断属性类型 U 是否包含 undefined，如果包含则返回 true，否则返回 false。最后，如果 T 是一个对象类型，则返回 true 或 false 类型，否则返回 never 类型。

然后，我们定义了一个 Person 接口，它包含一个必须属性 name 和一个可选属性 age。我们声明了两个变量 person1 和 person2，分别表示一个只有必须属性的 Person 对象和一个同时包含必须属性和可选属性的 Person 对象。

最后，我们使用 IsOptional 和 IsOptional 分别获取这两个对象的属性是否可选，并将它们声明为 true 或 false 类型。这样就可以根据对象类型的属性是否可选来确定返回类型。

2. 根据条件类型判断函数参数类型

  1. 案例一：
type FunctionReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

定义了FunctionReturnType条件类型，它会检查类型T是否为函数类型，如果是则通过infer获取函数的返回值类型R，否则返回never类型。具体案例如下：

type FRT1 = FunctionReturnType<() => number> //numbertype FRT2 = FunctionReturnType<(x: string, y: number) => string[]> //stringtype FRT3 = FunctionReturnType<() => void>//voidtype FRT4 = FunctionReturnType<() => {}>//{}type FRT5 = FunctionReturnType<1>//never
  1. 案例二：
 type ArgumentType<T> = T extends (arg: infer U) => any ? U : never;const foo = (arg: string) => {return arg.toUpperCase();
}const str: ArgumentType<typeof foo> = "hello"; // string

在这个例子中，我们定义了一个 ArgumentType 类型，它接受一个泛型类型参数 T。这个类型参数代表一个函数类型，我们通过 T extends (arg: infer U) => any 这个条件语句来判断 T 是否是一个函数类型，并提取其参数类型 U。如果 T 是一个函数类型，则返回参数类型 U，否则返回 never 类型。

然后，我们定义了一个 foo 函数，它接受一个字符串类型的参数，并将其转换为大写字母。我们使用 typeof 操作符来获取 foo 函数的类型，并通过 ArgumentType 来获取其参数类型。

  1. 案例三：

下面的示例演示在协变位置上同一类型变量的多个候选类型将会被推断为联合类型：

type Foo<T> = T extends { a: infer U, b: infer U } ? U : never;
type t1 = Foo<{ a: string, b: string }>;  // string
type t2 = Foo<{ a: string, b: number }>;  // string | number

同样在逆变位置上同一类型变量的多个候选类型将会被推断为交叉类型：

type Bar<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
type t1 = Bar<{ a: (x: string) => void, b: (x: string) => void }>;  // string
type t2 = Bar<{ a: (x: string) => void, b: (x: number) => void }>;  // string & number

协变与逆变

3. 根据类型的属性来判断函数的返回类型

假设我们有一个名为 fetchData 的函数，它从服务器获取数据并将其解析为特定类型。我们希望函数的返回类型根据请求的不同而有所区别，因此我们可以使用条件类型来实现这一点。

interface User {name: string;age: number;
}interface Post {title: string;content: string;
}type RequestType = "user" | "post";const fetchData = <T extends RequestType>(type: T): T extends "user" ? User : Post => {// 根据请求类型获取不同的数据if (type === "user") {return { name: "John", age: 30 } as any;} else {return { title: "TypeScript is awesome", content: "..." } as any;}
}const user = fetchData("user"); // User 类型
const post = fetchData("post"); // Post 类型

在这个例子中，我们定义了一个名为 fetchData的函数，它接受一个泛型类型参数 T，这个类型参数代表请求的类型，可以是 user 或 post。我们使用条件类型 T extends “user” ? User : Post 来决定返回的类型，如果请求的类型是 user，则返回 User 类型，否则返回 Post 类型。

然后，我们在函数体中根据请求类型获取不同的数据，返回的类型也会根据请求类型发生变化。

最后，我们分别调用 fetchData函数，并将其返回值分别赋值给 user 和 post 变量，这样就可以根据请求类型获取不同的数据，并且保证返回类型的正确性。

4. 根据类型的成员来判断其他类型

假设我们有一个名为 HasName 的类型，它表示一个具有 name 属性的类型。我们希望定义一个名为 PickWithName 的类型，它接受一个泛型类型参数 T，并从中选择具有 name 属性的子类型。

interface User {name: string;age: number;
}interface Post {title: string;content: string;
}type HasName = { name: string };type PickWithName<T> = T extends HasName ? T : never;type UserWithName = PickWithName<User>; // User 类型
type PostWithName = PickWithName<Post>; // never 类型

在这个例子中，我们定义了一个 HasName类型，它代表具有 name属性的类型。然后，我们定义了一个名为 PickWithName 的类型，它接受一个泛型类型参数 T，并使用条件类型 T extends HasName ? T : never 来判断 T 是否具有 name属性，如果是，则返回 T，否则返回 never 类型。

最后，我们分别使用 PickWithName 类型别名 PickWithName 来选择具有 name属性的子类型，并将其分别赋值给 UserWithName 和 PostWithName 变量。

5. 根据类型的可选属性来添加或删除属性修饰符

假设我们有一个名为 Person 的类型，它有两个属性 name 和 age，其中 name 属性是必需的，而 age 属性是可选的。我们希望定义一个名为 MakeFieldsOptional 的类型，它接受一个泛型类型参数 T，并将 T 中所有可选属性的修饰符从必需改为可选，将所有必需属性的修饰符保持不变。

type Person = {name: string;age?: number;
};type MakeFieldsOptional<T> = {[P in keyof T]?: T[P];
};type OptionalPerson = MakeFieldsOptional<Person>; // { name?: string; age?: number; }

在这个例子中，我们首先定义了一个 Person 类型，它有一个必需的 name 属性和一个可选的 age 属性。

然后，我们定义了一个名为 MakeFieldsOptional 的类型，它使用映射类型 [P in keyof T]?: T[P]，将 T 中所有可选属性的修饰符从必需改为可选，将所有必需属性的修饰符保持不变。

最后，我们使用 MakeFieldsOptional 类型别名来将 Person 类型中所有可选属性的修饰符从必需改为可选，将其赋值给 OptionalPerson 变量。

6. 元组转为联合类型 tuple转union

[string, number] -> string | number

type ElementOf<T> = T extends Array<infer P> ? P : never;
type Tuple = [string, number];
type TupleToUnion = ElementOf<Tuple>; // type TupleToUnion = string | number

7. 联合类型转成交叉类型

string | number -> string & number

type T1 = { name: string };
type T2 = { age: number };
type ToIntersection<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
// 由于U需要同时满足T1的定义、T2的定义，因此U需要包含T1、T2所有的类型，因此T3就是T1 & T2
type T3 = ToIntersection<{ a: (x: T1) => void, b: (x: T2) => void }>; // type T3 = T1 & T2

重点：

  • U extends any 是具有分布式有条件类型特性，因为待检查类型 U 为裸类型
  • (U extends any ? (k: U) => void : never) extends ((k: infer I)=> void) 最后一个 extends 前面作为待检查类型，因为被函数包装，因此不具有分布式有条件类型特性
   type UnionToIntersection<U> = ((k: string) => void | (k: number) => void) extends ((k: infer I) => void) ? I : never;

根据 逆变特性 推断出的 I 应该具备 string 和 number 的类型，故为交叉类型 string & number，而该交叉类型在 vscode 中表现为 never

六、结合keyof关键字

1. 获取对象属性类型

keyof主要是获取某个对象/类型的属性名来构成新类型。我们可以使用条件类型和 keyof 关键字来获取对象的属性。具体案例如下：

type PropertyType<T, K extends keyof T> = K extends keyof T ? T[K] : never;

上面代码定义了类型为PropertyType<T, K extends keyof T>，通过检查K是否是T的一个属性名，如果是则返回该属性类型，否则返回never。

type Obj = { a: string; b: number };
type A = PropertyType<Obj, "a">; // string
type B = PropertyType<Obj, "c">; // never

2. 实现映射类型

映射类型是泛型类型的一种，可用于把原有的对象类型映射成新的对象类型。我们可以使用条件类型和 keyof关键字来实现Partial类型，Partial类型是TS工具类之一。具体案例如下：

type Partial<T> = {[K in keyof T]? : T[K]
}

定义类型Partial，遍历T中所有属性，然后通过?将所有属性变成可选属性。

type obj = {a:string,b:number}
type R = Partial<obj>//{a?:string,b?:number}

注意：Partial是TS的工具类，所以声明Partial是会报错的，可以换个标识符名称。
在这里插入图片描述

七、内置条件类型

 // 找出T中不包含U的部分type Diff<T, U> = T extends U ? never : T;type R1 = Diff<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R1: 'd'// 由于U中的'a','b','c'都是T中的子类型，因此R1的类型就是'd'// 找出T中包含U的部分type Filter<T, U> = T extends U ? T : never;type R2 = Filter<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R2: 'a' | 'b' | 'c'

1. Exclude

  • 从T中排除掉U，和上面的Diff相同
type Exclude<T, U> = T extends U ? never : T;
type R3 = Exclude<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R3: 'd'

2. Extract

  • 从T中找出包含U的部分，和上面的filter相同
type Extract<T, U> = T extends U ? T : never;
type R4 = Extract<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R4: 'a' | 'b' | 'c'

3. NonNullable

  • 从T中找出不为null和undefined的参数
type NonNullable<T> = T extends null | undefined ? never : T;
type R5 = NonNullable<'a' | null | undefined | 'd'>; // R5: 'a' | 'd'

4. ReturnType 和 Parameters

  • infer：推断的意思，是一个关键字
  • ReturnType 获取函数的返回类型
  • Parameters 获取函数参数类型，返回一个元组
  // 1.1// ReturnType 获取函数的返回类型type ReturnType<T> = T extends (...args: any[]) => infer R ? R : T;function getUser() {return {name: '张三',age: 10}}// TS可以从参数中推断返回值类型type ReturnUser = ReturnType<typeof getUser>; // type ReturnUser = {name: string;age: number;}// 1.2// Parameters 获取函数参数类型，返回一个元组type Parameters<T> = T extends (...args: infer P) => any ? P : never;function getPerson(a: string, b: number) {return {name: '李四',age: 18}}type ParamsType = Parameters<typeof getPerson>; // type ParamsType = [a: string, b: number]

5. InstanceType 和 ConstructorParameters

  • InstanceType 获取构造函数的实例类型
  • ConstructorParameters 获取类的构造函数的参数类型
namespace e {class Person {name: string;constructor(name: string) {this.name = name;}getName() {console.log(this.name);}}// ConstructorParameters 获取类的构造函数的参数类型type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;type Params = ConstructorParameters<typeof Person> // type Params = [name: string]// InstanceType 获取构造函数的实例类型type Instance = InstanceType<typeof Person>;let instance: Instance = {name: '张三',getName() {}}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/1718.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

小程序首页轮播图设计

小程序首页轮播图设计

效果图 微信小程序的数据详解 indicator-dots&#xff1a;是否显示面板指示点【默认false 】 indicator-color&#xff1a;指示点颜色【默认rgba(0, 0, 0, .3)】 indicator-active-color&#xff1a;当前选中的指示点颜色【默认#000000】 autoplay&#xff1a;是否自动切换…
阅读更多...
Redis的过期策略以及内存淘汰机制

Redis的过期策略以及内存淘汰机制

目录 一、过期策略1.1、定时删除1.1.1、过期1.1.2、过期的 key 集合1.1.3、定时扫描策略1.1.4、 Redis 中所有的 key 在同一时间过期了&#xff0c;会出现怎样的结果1.1.5、从库的过期策略 1.2、惰性删除1.3、定时删除和惰性删除的总结 二、缓存淘汰算法2.1、缓存淘汰算法概述2…
阅读更多...
ngsoc使用指南

ngsoc使用指南

和威胁告警差不多。 ngsoc是以资产为核心&#xff0c;以安全事件为管理的关键流程&#xff0c;建立一套威胁检测&#xff0c;相应&#xff0c;预测&#xff0c;和持续监控分析&#xff0c;一体化的监控与相应平台。 和天眼的区别&#xff1a;会把天眼的告警&#xff0c;其他安…
阅读更多...
MFC扩展库BCGControlBar Pro v33.5新版亮点 - 其他增强功能

MFC扩展库BCGControlBar Pro v33.5新版亮点 - 其他增强功能

BCGControlBar库拥有500多个经过全面设计、测试和充分记录的MFC扩展类。 我们的组件可以轻松地集成到您的应用程序中&#xff0c;并为您节省数百个开发和调试时间。 BCGControlBar专业版 v33.5已正式发布了&#xff0c;此版本包含了Ribbon&#xff08;功能区&#xff09;自定义…
阅读更多...
Ansible自动化运维工具的认识

Ansible自动化运维工具的认识

目录 一、Ansible概述 二、Ansible特点 三、Ansible应用 1、使用者 2、Ansible工具集合 3、作用对象 四、Ansible的搭建 1、实验环境 2、环境准备 Ansible&#xff1a; 3、创建ssh免密交互登录 client端环境准备 五、Ansible配置 六、Ansible命令 1、ansible 实…
阅读更多...
【软件测试】web测试bug定位思路总结，“我“不再背锅...

【软件测试】web测试bug定位思路总结，“我“不再背锅...

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 需要掌握的知识 …
阅读更多...
ASUS华硕ROG幻14 2021款GA401QM原厂Win10系统工厂模式带ASUS Recovery恢复功能

ASUS华硕ROG幻14 2021款GA401QM原厂Win10系统工厂模式带ASUS Recovery恢复功能

自带恢复分区、所有驱动、出厂主题壁纸LOGO、Office办公软件、奥创控制中心等预装程序 所需要工具&#xff1a;16G或以上的U盘(非必需) 文件格式&#xff1a;HDI,SWP,OFS,EDN,KIT,TLK多个底包 文件大小&#xff1a;11.34GB 注&#xff1a;恢复时会清空电脑上所有盘的数据&…
阅读更多...
系列七、VMware中的CentOS服务不息屏

系列七、VMware中的CentOS服务不息屏

一、场景 VMware中安装好CentOS7等虚拟机后&#xff0c;过一段时间会自动息屏&#xff0c;这个时候如果想执行操作&#xff0c;需要重新输入 用户名/密码&#xff0c;体验感不好。 二、解决方法 应用程序》系统工具》设置》Privacy》锁屏》自动锁屏&#xff08;关闭&#xff0…
阅读更多...
SpringBoot 统一功能的处理

SpringBoot 统一功能的处理

SpringBoot 统一功能的处理 文章目录 SpringBoot 统一功能的处理1. 用户登录权限校验1.1 最初用户登录验证1.2 Spring AOP 统一用户登录验证的问题1.3 SpringAOP 拦截器1.3.1 实现自定义拦截器1.3.2 将自定义拦截器加入到系统配置 1.4 拦截器实现原理1.4.1 实现流程图1.4.2 实现…
阅读更多...
Java 串口通讯 Demo

Java 串口通讯 Demo

为什么写这篇文章 之前职业生涯中遇到的都是通过tcp协议与其他设备进行通讯&#xff0c;而这个是通过串口与其他设备进行通讯&#xff0c;意识到这里是承重板的连接&#xff0c;但实际上比如拉力、压力等模拟信号转换成数字信号的设备应该是有相当一大部分是通过这种方式通讯的…
阅读更多...
Redis数据结构 — List

Redis数据结构 — List

目录 链表结构设计 ​编辑链表节点结构设计 链表的优势与缺陷 Redis 的 List 对象的底层实现之一就是链表。C 语言本身没有链表这个数据结构的&#xff0c;所以 Redis 自己设计了一个链表数据结构。 链表结构设计 typedef struct list {//链表头节点listNode *head;//链表…
阅读更多...
软件测试人员的基本功包括哪些？

软件测试人员的基本功包括哪些？

什么是基本功&#xff1f;百度到的结果是&#xff1a;从事某种工作所必需的基本的知识和技能。 推理1&#xff1a;“基本”二字&#xff0c;意味着基本功必定是来源测试工作的基本流程。 推理2&#xff1a;“必须”二字&#xff0c;就意味者无论你是高级的测试开发&#xff0c;…
阅读更多...
spring.profiles的使用详解

spring.profiles的使用详解

本文来说下spring.profiles.active和spring.profiles.include的使用与区别 文章目录 业务场景spring.profiles.active属性启动时指定 spring.profiles.include属性配置方法配置位置配置区别 用示例来使用和区分测试一测试二测试三 编写程序查看激活的yml文件本文小结 业务场景 …
阅读更多...
TypeScript 学习笔记 环境安装-类型注解-语法细节-类-接口-泛型

TypeScript 学习笔记 环境安装-类型注解-语法细节-类-接口-泛型

文章目录 TypeScript 学习笔记概述TypeScript 开发环境搭建 类型注解类型推断 数据类型JS的7个原始类型Array数组object、Object 和 {}可选属性 ? 和 可选链运算符?. function函数TS类型: any类型 | unknow类型TS类型: void类型TS类型&#xff1a;never类型 &#xff08;几乎…
阅读更多...
noSQL的小练习

noSQL的小练习

目录 Redis&#xff1a; 1、 string类型数据的命令操作&#xff1a; 2、 list类型数据的命令操作&#xff1a; 3、 hash类型数据的命令操作&#xff1a; MongoDB&#xff1a; 1. 创建一个数据库 名字grade 2. 数据库中创建一个集合名字 class 3. 集合中插入若…
阅读更多...
C++基础算法二分篇

C++基础算法二分篇

&#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;C算法 &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&#x1f349;留言 主要讲解二分算法&#xff0c;分别讲解了整数二分和浮点二分 文章目录…
阅读更多...
MobPush:Android SDK 集成指南

MobPush:Android SDK 集成指南

开发工具&#xff1a;Android Studio 集成方式&#xff1a;Gradle在线集成 安卓版本支持&#xff1a;minSdkVersion 19 集成准备 注册账号 使用PushSDK之前&#xff0c;需要先在MobTech官网注册开发者账号&#xff0c;并获取MobTech提供的AppKey和AppSecret&#xff0c;详情可…
阅读更多...
elasticsearch基本操作

elasticsearch基本操作

elasticsearch 下面参数详细解释 java 搜索查询看官方文档 https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/8.8/connecting.html#_your_first_request{"name" : "Tom Foster","cluster_name" : "elasticsearch&q…
阅读更多...
vue3+vite+ts+vant 开发浙里办H5应用流程和注意事项

vue3+vite+ts+vant 开发浙里办H5应用流程和注意事项

vue3vitets 开发浙里办H5应用流程和注意事项 最近有个项目是要开发到浙里办的一个H5项目,记录一些问题; 浙里办irs系统内node版本和npm版本如下建议切到他们的版本再进行开发这样问题少一点 1.因为浙里办有自己的irs系统 需要吧前端整体的代码传上去 除了 打包后的dist 和 no…
阅读更多...
【Win10系统下载Python3】

【Win10系统下载Python3】

Python3官网&#xff1a;https://www.python.org/downloads/windows/ 注
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023