Typescript类型运算符、关键字以及内置高级类型

类型运算符

|运算符

&运算符

类型关键字

Infer

示例

extends

typeof

keyof

注意

内置高级类型

类型

PropertyKey

ArrayBufferLike

对类型集合的操作

Exclude,>

Extract,>

对类型的操作

NonNullable

Readonly

Required

Partial

Pick ,>

Omit,>

Record

对字符串类型的操作

Uppercase

~~Lowercase~~

~~Capitalize~~

~~Uncapitalize~~

~~对函数、类、Promise类型的操作~~

~~ThisParameterType~~

~~OmitThisParameter~~

~~Parameters~~

~~ConstructorParameters~~

~~ReturnType~~

~~InstanceType~~

~~Awaited~~

类型运算符

|运算符

或连接表示需要满足其中一种类型

type Name1 = { name: string; }
type User1 = Name1 | { age: number; } //type User = {name: string}|{ age: number;}
let user1: User1 = { name: 'yf' } // 只需要满足其中一个类型

&运算符

与连接表示需要同时满足两个类型

type Name2 = { name: string; }
type User2 = Name2 & { age: number; } // type User = {name: string; age: number;}
let user2: User1 = { name: 'yf', age: 18 } // 两个类型需要都满足

类型关键字

Infer

表示在 extends 条件语句中以占位符出现的用来修饰数据类型的关键字，被修饰的数据类型等到使用时才能被推断出来。

示例

// 定义了一个接口Customer，它描述了一个具有name（字符串类型）和moneyPaid（数字类型）属性的对象
interface Customer {name: stringmoneyPaid: number
}
// 定义了一个函数类型，接收一个Customer类型的参数并返回一个字符串
type custFuncType = (cust: Customer) => string
// 定义了一个泛型类型inferType<T>，这是理解的重点。这是一个条件类型，它使用了infer关键字,这里是一个三元判断返回类型P或T
// 表示传入的T如果是函数且只有1个参数则返回参数的类型，否则返回函数本身
type inferType<T> = T extends (params: infer P) => any ? P : T 
// 定义了inferResultType类型别名，它是通过将前面定义的custFuncType类型作为参数传递给inferType得到的
type inferResultType = inferType<custFuncType> // type inferResultType = Customer
let inferVariable: inferResultType = { name: "yf", moneyPaid: 9999 };
//如果custFuncType的函数没有参数，这里的inferResultType相当于any

extends

1.用于类型集合表示A extends B,表示A是B中的一个子类型。

2.用于类A extends B表示，B类中的属性在A类中需要被实现（A>B)。

type MyExtends = b extends bb ? 1 : 2 
//bb中的say属性在b类中没有被实现，所以返回三元中false的项即 type MyExtends1 = 2
type MyExtends1 = number extends number|string ? 1 : 2 // type MyExtends1 = 1

typeof

可以将变量转化为类型

function square(a: number) { return a * a }
type squareType = typeof square;//type squareType = (a: number) => number

keyof

返回对象类型属性名的集合

type Man = {name: string;age: number;
}
type MyKeyof = keyof Man // type MyKeyof = "name" | "age"

in

用于循环对象类型的属性名，创建新对象属性

type StringifyProperty = {[P in 'name'|'age']: string;};
//type StringifyProperty = {name: string;age: string;}

注意

1.void类型对应null和undefined

2.对函数参数、数组的类型定义不约束参数的名字，只约束指定位置的类型

3.类型定义时，函数中的第一个参数可以用来定义函数中的this类型,在使用时会判断函数中的this是否符合要求。

let thisFun = function (this: { name: String }, a: number) { console.log(a); console.log(this, 11) };
// thisFun(1,"2") 报错，因为this为undefined，没有name属性。
let thisObj = { name: "yf", moneyPaid: 9999, thisFun };
thisObj.thisFun(1) //这里this为thisObj包含name属性且为字符串所以不会报错。

内置高级类型

类型

PropertyKey

type PropertyKey = string | number | symbol;

定义对象的属性可以为哪些类型值。

ArrayBufferLike

type ArrayBufferLike = ArrayBufferTypes[keyof ArrayBufferTypes];

返回ArrayBuffer类型对象，需要有byteLength，slice，[Symbol.toStringTag]属性

// 定义一个符合ArrayBufferLike接口的自定义对象
const customBufferLike: ArrayBufferLike = {byteLength: 10,slice: function (start, end) {// 实现slice方法，这里只是一个简单的示例// 实际的slice方法需要返回原始buffer的一个新的slicereturn this.subarray(start, end) // 假设subarray方法已经实现},[Symbol.toStringTag]: "aaa"
};
console.log(customBufferLike.toString()) //'[object aaa]'

对类型集合的操作

Exclude<T, U>

type Exclude<T, U> = T extends U ? never : T;

T中包含U属性则返回never，不包含则返回T。即从T类型集合中排除U类型后的集合

type MyExclude = Exclude<string | number | boolean, string> 
// type MyExclude = number | boolean

Extract<T, U>

type Extract<T, U> = T extends U ? T : never;

T中包含U属性则返回U，不包含则返回never。即从T类型集合中抽取U类型后的集合

type MyExtract = Extract<string | number | boolean, string> 
//type MyExtract = string

对类型的操作

NonNullable<T>

type NonNullable<T> = T & {};

如果T对象类型为null或者undefined则返回never，其它返回T。

type MyNonNullable = NonNullable<null> // type MyNonNullable = never

Readonly<T>

type Readonly<T> = {readonly [P in keyof T]: T[P];
};

将T类型中所有属性都设置为只读属性

interface Person {name?: string;age?: number;
}
type ReadonlyPerson = Readonly<Person>;
//type PartialPerson = {readonly name?: string;readonly age?: number;}

Required<T>

type Required<T> = {[P in keyof T]-?: T[P];
};

将T类型下的所有属性都设置为必选的

interface Person {name?: string;age?: number;
}
type RequiredPerson = Required<Person>;
//type PartialPerson = {name: string; age: number;}

Partial<T>

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

将T类型下的所有属性都设置为可选类型。

interface Person {name: string;age: number;
}
type PartialPerson = Partial<Person>;
//type PartialPerson = {name?: string; age?: number;}

Pick<T, K >

type Pick<T, K extends keyof T> = {[P in K]: T[P];
};

选取T类型中的部分属性，不改变属性的要求返回。

interface Person {name?: string;age?: number;gender: string;
}
type MyPick = Pick<Person, "name" | "age"> 
// type MyPick = { name?: string;age?: number;}

Omit<T, K >

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

从T对象类型中删除K属性。

interface Person {name?: string;age?: number;gender: string;
}
type MyOmit = Omit<Person, "name">  
// type MyOmit = {age?: number;gender: string;}

Record<K , T>

type Record<K extends keyof any, T> = {[P in K]: T;
};

返回新的类型对象，该对象中的属性为K类型集合中的每个类型，对应的每个值都为T类型。

interface Person {name?: string;age?: number;gender: string;
}
type MyRecord = Record<"name" | "color", Person> 
// type MyRecord = {name: Person4;color: Person;}

对字符串类型的操作

Uppercase<S>

type Uppercase<S extends string> = intrinsic;

将StringType转为大写，TS以内置关键字intrinsic来通过编译期来实现。

type MyUppercase = Uppercase<"yf"> 
// type MyUppercase = "YF"

Lowercase<S>

type Lowercase<S extends string> = intrinsic;

将StringType转为小写，TS以内置关键字intrinsic来通过编译期来实现。

type MyLowercase = Lowercase<"YF" | "HH"> 
// type MyLowercase = "yf" | "hh"

Capitalize<S>

type Capitalize<S extends string> = intrinsic;

将StringType的第一个字符转为大写，TS以内置关键字intrinsic来通过编译期来实现。

type MyCapitalize = Capitalize<"yf" | "hh"> 
// type MyCapitalize = "Yf" | "Hh"

Uncapitalize<S>

type Uncapitalize<S extends string> = intrinsic;

将StringType的第一个字符转为小写，TS以内置关键字intrinsic来通过编译期来实现。

type MyUncapitalize = Uncapitalize<"YF" | "HH"> 
// type MyUncapitalize = "yF" | "hH"

对函数、类、Promise类型的操作

ThisParameterType<T>

type ThisParameterType<T> = T extends (this: infer U, ...args: never) => any ? U : unknown;

ThisParameterType表示提取函数中的this类型，如果没有this或传入的T不为函数返回unknown类型

type MyThisParameterType = ThisParameterType<(this: Number, x: number) => void>;// T = Number

OmitThisParameter<T>

type OmitThisParameter<T> = unknown extends ThisParameterType<T> ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T;

OmitThisParameter表示删除函数T中的this参数返回。

即如果ThisParameterType<T>返回为unknown则直接返回T，如果不为unknown则返回删除T函数中对函数参数的this变量的约束

function toBinary(this: Number) {return this.toString(2);
}
let five2Binary: OmitThisParameter<typeof toBinary> = toBinary.bind(8);
//OmitThisParameter<typeof toBinary>返回 () => string

Parameters<T >

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

如果T是一个函数则返回函数参数中数组以及数组每一位对应值的类型,否则为never。即获取函数T的参数类型。

type MyParameters = Parameters<(this: number, x: number, y: string) => void>; 
// type MyParameters = [x: number, y: string]
let variableParameters: MyParameters = [1, 'a']

ConstructorParameters<T >

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

如果T是一个类类型则返回该类中构造函数参数中数组以及数组每一位对应值的类型,否则为never。获取T类中构造函数的参数类型

interface IAnimal {new(name: string, age: number)
}
type MyConstructorParameters = ConstructorParameters<IAnimal> 
// type MyConstructorParameters = [name: string, age: number]

ReturnType<T >

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

如果T是一个函数则返回函数参数中数组以及数组每一位对应值的类型,否则为never。即获取函数T的返回值类型。

type MyReturnType = ReturnType<(this: number, x: number) => void> 
// type MyReturnType = void

InstanceType<T >

type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

如果T是一个类类型则返回该类中构造函数返回的类型,否则为any。获取T类构造函数的返回值类型，即T的实例对象。

class MyClass {constructor(public name: string) { }
}
// 获取 MyClass 的实例类型
type MyInstanceType = InstanceType<typeof MyClass>;
// 使用 MyInstanceType 创建对象
const instance: MyInstanceType = new MyClass("World");

Awaited<T>

type Awaited<T> =T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` modeT extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrappedF extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argumentAwaited<V> : // recursively unwrap the valuenever : // the argument to `then` was not callableT; // non-object or non-thenable

表示如果T为Promise函数则取出Promise函数中返回的内容，如果不是则返回T类型，可以相当于Awaited<T> = typeof T extends Promise<infer U> ? U : typeof T;

用于递归解包 Promise，模拟函数 await 或 .then() 方法的行为。

let aa = Promise.resolve('aa')
type AA = Awaited<typeof aa> //type AA = string