Ts中内置类型

Ts
是js的超集，可以编译成js，主要提供类型检查的作用

Ts内置类型
ts内置了一些类型，这些类型可以进行其他类型的类型转化

具体类型
Partial
作用
Partial 构造一个类型 使T里的所有属性都设置可选

实现
type Partial = { [P in keyof T]?: T[P] | undefined; }

使用
interface Exp1 {
    name: string;
    age:number;
}
type PartialExp1  = Partial

PartialExp1 的类型

type PartialExp1 = {
    name?: string | undefined;
    age?: number | undefined;
}

Required
作用
Required 使T 所有属性都设为required 与partial相反

实现
type Required = { [P in keyof T]-?: T[P]; }

使用
interface Exp2  {
    name?:string;
    age:number;
}
type RequireExp2  = Required

RequireExp2的类型为：

type RequireExp2 = {
    name: string;
    age: number;
}

Readonly
作用
Readonly 将type中所有属性设置为只读

实现
type Readonly = { readonly [P in keyof T]: T[P]; }

使用
interface Exp3 {
    name:string;
    age:number;
}
type ReadonlyExp3 = Readonly;

ReadonlyExp3:

type ReadonlyExp3 = {
    readonly name: string;
    readonly age: number;
}

Record
作用
Record 构造一个类型 属性键为keys 属性名位T 。可以用来规定对象的属性 名 以及值的类型

实现
type Record = { [P in K]: T; }

使用
type Exp4 = 'A'|'B'|'C'
type RecordExp4  = Record

interface Exp5{
    title:string;
}
type RecordExp5=  Record

使用后类型为：

type RecordExp4 = {
    A: number;
    B: number;
    C: number;
}
type RecordExp5 = {
    A: Exp5;
    B: Exp5;
    C: Exp5;
}

Pick
作用
Pick 从Type中选出一组keys来构造一个类型

实现
type Pick = { [P in K]: T[P]; }

使用
interface Exp6 {
    title:string;
    age:number;
    sex:number
}
type PickExp6 = Pick

结果为：

type PickExp6 = {
    title: string;
    age: number;
}

Omit
作用
Omit 从Type中删除所有keys 来构造一个类型 与PIck相反

实现
type Omit = { [P in Exclude]: T[P]; }

使用
interface Exp7 {
    title: string;
    age:number;
    sex:number
}
type OmitExp7  = Omit

结果为：

type OmitExp7 = {
    age: number;
    sex: number;
}

Exclude
作用
Exclude 从T中排除可分配给U的的类型，返回联合类型

实现
在extends 联合类型时 会分布式的去比较

type Exclude = T extends U ? never : T

使用
type Exp8 = 'title' | 'age' | 'sex';
type Exp9 = 'title'|'age';
type Exclude8 = Exclude

结果为

type Exclude8 = "sex"

Extract
作用
Extract 从T中提取可以分配给U的属性构造成一个新的联合类型 和Exclude相反

实现
type Extract = T extends U ? T : never

使用
type Exp10 = 'title' | 'age' | 'sex';
type Exp11 = 'title'|'age';
type ExtractExp10 = Extract

结果为

type ExtractExp10 = "title" | "age"

NonNullable
作用
NonNullable 从 T中排除 null 和 underfined 来构造一个类型

实现
type NonNullable = T & {}

使用
type Exp12 = string|null|number|undefined;
type NonNullableExp12 = NonNullable

结果为

type NonNullableExp12 = string | number

Parameters
作用
Parameters 从 函数类型T中使用的参数类型 构造元组类型

实现
现在在有条件类型的 extends 子语句中，允许出现 infer 声明，它会引入一个待推断的类型变量。 这个推断的类型变量可以在有条件类型的 true 分支中被引用。 允许出现多个同类型变量的 infer。

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

使用
type Exp13 = (title:string,age:number)=>void;
type ParametersExp13 = Parameters

结果：

type ParametersExp13 = [title: string, age: number]

ConstructorParameters
作用
ConstructorParameters 从构造函数的参数类型来构造元组类型

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

使用
interface Exp14 {
    new(title:string,age:number):Object
}
type ConstructorParametersExp14 = ConstructorParameters

结果为：

type ConstructorParametersExp14 = [title: string, age: number]

ReturnType
作用
ReturnType 构造一个由函数类型 T返回类型组成的类型

实现
type ReturnType any> = T extends (...args: any) => infer R ? R : any

使用
type Exp15 = (title:string,age:number) => string| number;
type ReturnTypeExp15 = ReturnType

结果：

type ReturnTypeExp15 = string | number

InstanceType
作用
InstanceType 返回由T中构造函数的实例组成的类型

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

使用
interface Exp17{
  title:string;
  age:number
}
interface Exp16  {
    new(title:string,age:number):Exp17;
}
type InstanceTypeExp16 =  InstanceType

结果

type InstanceTypeExp16 = Exp17

ThisParameterType
作用
ThisParameterType 返回T函数类型中this参数的类型，无返回unkonwn

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

使用
// 声明
type Exp18 = (this:number)=>number;
type ThisParameterTypeExp18 = ThisParameterType
// 未声明
type Exp181 = (age:number)=>number;
type ThisParameterTypeExp181 = ThisParameterType

结果：

// 声明
type ThisParameterTypeExp18 = number
// 未声明
type ThisParameterTypeExp181 = unknown

OmitThisParameter
作用
OmitThisParameter 从 T函数类型中移除this参数 如果不存在 返回T 存在这创建一个不带此参数的新函数类型

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

使用
type Exp19 = (this:number,age:number,title:string)=>number;
type OmitThisParameterExp19 = OmitThisParameter

结果：

type OmitThisParameterExp19 = (age: number, title: string) => number

ThisType
作用
ThisType 在对象字面量中键入this 为Type，并可以通过上下文类型控制this类型

实现
使用限制：

在–noImplicitThis的选项下起效
仅支持在对象字面量上下文中使用，在其他地方使用相当于空接口
interface ThisType

使用
type Exp20 = {bar:()=>void}
type ThisTypeExp20 = Exp20 & ThisType<{title:string}>
const Exp20: ThisTypeExp20 = {
    bar() {
         console.log(this.title); 
    }
}

结果：

this: {
    title: string;
}

Uppercase & Lowercase
作用
将StringType转为全大写/小写，ts通过内置关键字intrinsic在编译器实现

实现
type Uppercase = intrinsic
type Lowercase = intrinsic

使用
// Uppercase
type Exp21 = 'titLe';
type UppercaseExp21 = Uppercase

// Lowercase
type Exp22 = 'TiTLE';
type LowercaseExp22 = Lowercase

结果：

type UppercaseExp21 = "TITLE"
type LowercaseExp22 = "title"

Capitalize & Uncapitalize
作用
将 string type 首字母转为大写/小写，通过关键字 intrinsic编译阶段实现

实现
type Capitalize = intrinsic
type Uncapitalize = intrinsic

使用
//Capitalize
type Exp23  = 'title';
type CapitalizeExp23 = Capitalize

// Uncapitalize
type Exp24 = 'Title'
type UncapitalizeExp24 = Uncapitalize

结果：

type CapitalizeExp23 = "Title"
type UncapitalizeExp24 = "title"