ts补充

// ts中类型主要包括 1.元组 2.接口(对象，函数，构造器)类型 3.枚举类型 4.字面量类型 5.特殊类型

// ts中类型类型运算主要包括 1.条件类型 : 2.推导类型 3.联合类型 4.交叉类型 5.映射类型

特殊类型

never 代表不可达，比如函数抛异常的时候，返回值就是 never。
void 代表空，可以是 undefined 或 never。
any 是任意类型，任何类型都可以赋值给它，它也可以赋值给任何类型（除了 never）。

unknown 是未知类型，任何类型都可以赋值给它，但是它不可以赋值给别的类型。

extends 的不同用处

// extends ? :    条件类型

// extends  class   类继承

// T extends string  类型约束

// infer  推导类型

// | 联合类型

// & 交叉类型

// key of 映射类型

type MapType<T> = { [Key in keyof T]?: T[Key] }

keyof T 是查询索引类型中所有的索引，叫做索引查询

T[Key] 是取索引类型某个索引的值，叫做索引访问

//取出props类型

type GetRefType<P> = 'ref' extends keyof P ? P extends {ref : infer Value|undefined} ? Value : never : never

type ImplRefType = GetRefType<{name:"ws",ref:'ws'}>

类型约束例子

// function getPv(obj,key){

//         return obj[key]

// }

// function getpv<T>(obj:T,key:any):any{

//     return obj[key]

// }

function getPv<T extends object,Key extends keyof T>(obj:T,key:Key):T[Key]{

    return obj[key]

}

getPv({a:1,b:2},'a')

// ts 子类型父类型

//模式匹配

type GetReturnType<T> =  T extends (...args:unknown[])=> infer ReturnType ? ReturnType : never

type Type = GetReturnType<()=>string>

//递归

type GR<T extends string> = T  extends `${infer A}${' '}` ? GR<A> : T

type GL<T extends string> = T  extends `${' '}${infer A}` ? GL<A> : T

type A = GL<GR<'    ws    '>>

type obj = {

    a: {

        b: {

            c: {

                f: () => 'dong',

                d: {

                    e: {

                        guang: string

                    }

                }

            }

        }

    }

}

type DeepReadOnly<T extends Record<string,any>> = {

     readonly [key in keyof T] :T[key] extends object ? T[key] extends Function ? T[key] : DeepReadOnly<T[key]> :T[key] } 

type DRR = DeepReadOnly<obj>

//重新构造

type UppercaseKey<T extends object> = {

    [Key in keyof T as Uppercase<Key & string>] : T[Key]

}

// key in 'NAME'|'AGE'

type GG = UppercaseKey<{name:string;age:number}>

type Change<T> = {

    [Key in keyof T as `${Key & number}` ]:[T[Key],T[Key]]

}

type v = Change<{1:1,3:2}>

type AppendArgument<T,U> = T extends (...args:infer Args)=>infer A ? (...args:[...Args,U])=> A:never

type AppendArgumentResult = AppendArgument<(name:string)=>string,number>

type ToRe<T> = {

   -readonly [key in keyof T] -?: T[key]

}

type Ad = ToRe<{

   readonly a?:string;

   readonly b?:number

}>

interface P {

    name:string;

    age:number;

    hobby:string[];

}

type Filter<T extends Record<string,any>,U> = {

    [key in keyof T as U extends T[key] ? key :never]:T[key]//此处包含联合类型的特性

}

type FilterRt = Filter<P,string|number>

type JJ = string|number extends string ? true :false

//联合类型

联合类型比较特殊会有分布式条件类型A extends A ? [B] extends [A] ? false : true : never

当 A 是联合类型时：

A extends A 这种写法是为了触发分布式条件类型，让每个类型单独传入处理的，没别的意义。
A extends A 和 [A] extends [A] 是不同的处理，前者是单个类型和整个类型做判断，后者两边都是整个联合类型，因为只有 extends 左边直接是类型参数才会触发分布式条件类型。

至于为什么要用[A]这总形式其实在ts被解析的时候底层会直接传入是不是T(也就是联合类型) 如果是就按照分布式情况处理如果不是就正常处理所以以下都可以防止触发分布式条件类型

A extends A ? [B] extends [A] ? false : true : never

A extends A ? {ws:B} extends {ws:A} ? false : true : never

A extends A ? (()=>B) extends (()=>B)  ? false : true : never

type UppercaseA<T extends string> = T extends 'a' ? Uppercase<T> : T

type UppercaseAR = UppercaseA<'a'|'b'|'c'>

type IsUnion<A,B=A> = A extends A ? [B] extends [A] ? false : true : never

type IsUnionR = IsUnion<'a'|'b'>

//这个可以验证分布式条件类型

type TestUnion<A, B = A> = [B] extends [B] ? { a: A, b: B} : never;

type TestUnionResult = TestUnion<'a' | 'b' | 'c'>;

// 内置类型

// Parameters

// type Parameters<T extends (...args: any) => any>

//     = T extends (...args: infer P) => any

//         ? P

//         : never;

type TestParameters = Parameters<(name:string,age:never)=>void>

//Partial Readonly Required

//Pick

// type Pick<T, K extends keyof T> = {

//     [P in K]: T[P];

// };

type TestPick = Pick<{name:'ws',age:10,ddd:'12'},'name'|'age'>

//Record

// type Record<K extends keyof any, T> = {

//     [P in K]: T;

// };

type TestRecord = Record<'a'|'b',string>

type TestRecord2 = Record<string,any>

//Exclude

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

type TestExclude = Exclude<'a'|'b'|'c','a'|'b'>

//Extract

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

type TestExtract = Extract<'a'|'b'|'c','a'|'b'>

//Omit

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

type TestOmit = Omit<{name:'ws',age:10,ddd:'12'},'name'|'age'>

//协变逆变 //协变

interface Person {

    name: string;

} 

interface Ws {

    name: string;

    age: number;

}

let person: Person = {

    name: '',

};

let wangs: Ws = {

    name: 'ws',

    age: 20,

};

person = wangs;

// wangs = person;

//逆变

let printHobbies: (ws: Ws) => void;

printHobbies = (ws) => {

    console.log(ws.age);

}

let printName: (person: Person) => void;

printName = (person) => {

    console.log(person.name);

}

// printName = printHobbies

printHobbies = printName

// printHobbies()

type Func = (a: string) => '1';

const func: Func = (a: 'hello') => string

// type UnionToIntersection<U> =

//     (U extends U ? (x: U) => unknown : never) extends (x: infer R) => unknown

//         ? R

//         : never

// type UnionToIntersectionTest = UnionToIntersection<{ws:1}|{wsss:2}>

extends

// type ad = 'a'&'b' extends 'a' ? true :false; // type add = 'a' extends 'a'|'b' ? true :false type addf= ['a'|'b'] extends ['a'] ? true :false type addd= 'a'|'b' extends 'a' ? true :false

// type l = { // name:string, // } type DD = {a:'1111',b:'2'} extends {} ? true :false

// 子类型一定比父类型更具体

// type fff = ['a','b','c'][number] // type GG = fff extends 'a'|'b'|'c' ? true :false // type SSS = {1:1,2:2,3:3} extends {1:1} ?true :false // type EE = {a:2}

巴特西

ts补充

最新文章

热门文章