TS学习记录

extends

let a1:A1 = '1';

type A2 = 'y' extends 'x' ? string : number; //number
let a2:A2 = 2;

type A4 = 'x' | 'y' extends 'y' ? number : string; // string
let a4:A4 = '4';

type A5<T> = T extends 'y' ? number : string; //  string | number
type A6 = A5<'x'|'y'>;

infer

type GetLastType<T extends Array<any> = []> = T extends [infer F,...infer M,infer L] ? L : never;
type arr1 = [false,'',undefined,300];
type last = GetLastType<arr1>;


/**
 * 判断字符串是否包含子串
 * @example
 * type Result = Includes<"123", "12"> // true
 */
type Includes1<
  S1 extends string,
  S2 extends string
> = S1 extends `${infer Left}${S2}${infer Right}` ? Left : false;
type Result = Includes1<"1", "400"> // true

keyof

// keyof 用作数组时，为 数组的长度索引值
// 可以为 string 和 number 类型 
// string类型 最大值不可超过数组最大索引（从0开始计算）
// number类型无限制
// '0'|'1'|'2'|'3'|number
type Person2 = [undefined,null,1,'300'];
type P2 = keyof Person2;
let b:P2 = '1'; 


type Person = {
    name:string,
    age:number,
    sex:boolean,
}
// "name" | "age" | "sex"
type P1 = keyof Person; 
let a:P1 = 'age';

自定义方法

    /**
 * @param T 左边的数
 * @param K 右边的数
 * @param A 用来递归自增数组长度的
 *  传入两个数字 T和K，当T > K 返回true，K>T返回false
 * */ 
type MyType<T extends number,K extends number,A extends any[] = []> = 
    T extends A['length'] ? false :
        K extends A['length'] ? true : 
            MyType<T,K,[...A,1]>


let a:MyType<2,1> = true;
let b:MyType<3,6> = false;



// ---
type FlattenList<T extends any[]> = T extends [infer First, ...infer Last]
  ? First extends any[]
    ? [...FlattenList<First>,...FlattenList<Last>]
    : [First, ...FlattenList<Last>]
  : [];
type arr = [[1, 2], [[3, 5, [4]]]];
type Lr = FlattenList<arr>;
// [1,2,3,5,4]



type OtoA = {
    name:string,
    age:number,
    sex:boolean
}
type ObjectToArray<T,K = keyof T> = K extends keyof T ? [K,T[K]] : never;
type OTA = ObjectToArray<OtoA>;
// ['name',string] | ['age',number] | ['sex',boolean]



type GetTotal<T extends any[]> = {
    [K in keyof T] : T[K] extends () => infer R  ? R : T[K]
}
type Tup = [1,()=>number,string];

type Total = GetTotal<Tup>
// [1,number,string]


// 获取Function类型的
interface Ob{
    a:3,
    b:false,
    c:()=>30,
    d:()=>'FrontEnd'
}
type getFunc<T,TargetType> = {
    [K in keyof T] : T[K] extends TargetType ? K : never;
}[keyof T];
type Fun = getFunc<Ob,Function>;
//

实现部分数组方法

type Push<A, T> = A extends Array<any> ? [...A, T] : never;
type Pop<T> = T extends [...infer rest, infer P] ? [...rest] : never;
type Unshift<A, T> = A extends Array<any> ? [T, ...A] : never;
type Shift<T> = T extends [infer P, ...infer rest] ? [...rest] : never;
type Includes<T, U> = T extends [infer P, ...infer rest]
  ? U extends P
    ? true
    : Includes<rest, U>
  : false;
type Concat<T extends Array<any>, K extends Array<any>> = [...T, ...K]; // 不完整的

type Ftype = string | number | bigint | boolean | null | undefined;
type Join<T, Z extends Ftype = ","> = T extends [infer F, ...infer rest]
  ? F extends false
    ? ""
    : F extends Ftype
    ? rest extends []
      ? `${F}`
      : `${F}${Z extends "," ? "" : " "}${Z}${Z extends "," ? "" : " "}${Join<
          rest,
          Z
        >}`
    : ""
  : "";

type FlatArr<T extends any[]> = T extends [infer F, ...infer rest]
  ? F extends Array<any>
    ? [...FlatArr<F>, ...FlatArr<rest>]
    : [F, ...FlatArr<rest>]
  : [];

type Fill<T extends any[], C,N extends any[] = []> =  N['length'] extends T['length'] ? N : Fill<T,C,[...N,C]>
type ToString<T> = Join<T>;
type Reverse<T,R extends any[] = []> = T extends [infer F,...infer rest] ? Reverse<rest,[F,...R]> : R ;
type IndexOf<T,K,C extends any[] = []> = Includes<T,K> extends false ? -1 : (
    T extends [infer F,...infer rest] ? (
        F extends K ? C['length'] : IndexOf<rest,K,[...C,any]>
    ) : C['length']
)

type tuple = [1, 2, 3];
type tuple2 = [4, 5, 6];
type push = Push<tuple, 4>;
type pop = Pop<tuple>;
type unshift = Unshift<tuple, 10>;
type shift = Shift<tuple>;
type includes = Includes<tuple, 3>;
type concat = Concat<tuple, tuple2>;
type join = Join<tuple>;
type flat = FlatArr<[[1], [2, 3, [5]], [[123, 900, [40]]]]>;
type tostring = ToString<tuple>
type fill = Fill<tuple, 'LF'>;
type reverse = Reverse<tuple>;
type indexof = IndexOf<tuple,3>;

实现部分内置类型

type ExcludeCopy<T,U> = T extends U ? never : T;
type exclude = ExcludeCopy<'x'|'y','y'>;

type ExtractCopy<T,U> = T extends U ? T : never;
type extract = ExtractCopy<'a'|'b'|'c','b'|'c'>;

type RequiredCopy<T> = {
    [K in keyof T]-? : T[K]
}
type TestType2 = RequiredCopy<{a?:string}>;


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

type ReadonlyCopy<T> = {
    readonly [K in keyof T] : T[K]
}

type Information = {
    name:string,
    age:number,
    sex:boolean
}

type PickCopy<T,K extends keyof T> = {
    [U in K]:T[U]
}  
type PickTest = PickCopy<Information,'name'|'age'>;

type OmitCopy<T,U extends keyof any> = PickCopy<T,ExcludeCopy<keyof T,U>>

type TestOmit = OmitCopy<Information,'age'>;


type RecordCopy<T extends string | number | symbol,P> = {
    [K in T] : P
}
type TestRecord = RecordCopy<string,Information>;

type ReturnTypeCopy<T> = T extends (...params)=> infer P ? P : never;

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

const ReturnFunc = (p:string,a:boolean) => {
    return 3000;
}
type TF = typeof ReturnFunc;
type TestReturnType = ReturnTypeCopy<typeof ReturnFunc>

type TestGetParameter = GetParameterCopy<typeof ReturnFunc>

type NonNollable<T> = T extends null | undefined ? never : T;
type TestNonNollable = NonNollable<string | undefined | number | null >;