typescript 常见内置函数

在书写ts的时候，很多有重复的，或者需要变成可选的，以及书写返回的类型

type labelType = { id: string; name: string };
type test2 = Pick<labelType, 'name'>; // Ö»Òªname
type test3 = Omit<labelType, 'name'>; // ÌÞ³ýname
type test4 = Partial<labelType>; // ¿ÉÑ¡
type test5 = Required<labelType>; // ±ØÌî
type test = Record<'data', labelType[]>; // ¹æ·¶·µ»Ø
type Data = Record<string, unknown>;

const fn = () => [1, 2, 3, 'sad'];
const fn1 = (a: number, b: number): number => {
    return a + b;
};

type num = ReturnType<typeof fn>;
type num2 = ReturnType<typeof fn1>;

//Ô­Àí
type CustomExclude<T, K> = T extends K ? never : T;
type test6 = Exclude<'a' | 'b' | 'c', 'a' | 'b'>;

type CustomExtract<T, K> = T extends K ? T : never;
type test7 = Extract<'a' | 'b' | 'c', 'a' | 'w'>;

// infer
// interface User {
//     name: string;
//     age: number;
// }

// type Result = Promise<User>;
// type PromiseRes<T> = T extends Promise<infer R> ? R : never;
// type r = PromiseRes<Result>; // type r = User

// Èç¹ûÓöµ½Á˶à²ãµÄÇé¿ö¿ÉÒÔʹÓõݹé
// interface User {
//     name: string;
//     age: number;
// }

// type Result = Promise<Promise<Promise<User>>>;
// type PromiseRes<T> = T extends Promise<infer R> ? PromiseRes<R> : T;
// type r = PromiseRes<Result>; // type r = User

//  infer µÄЭ±ä
// let obj = {
//     name: 'СÂú',
//     age: 123
// };
// type protyKey<T> = T extends { name: infer N; age: infer A } ? [N, A] : T;
// type res = protyKey<typeof obj>; // type res = [string, number]

// »ñÈ¡¶ÔÏóÊôÐÔµÄÀàÐͲ¢ÇÒ·µ»ØÔª×éÀàÐÍ
// let obj = {
//     name: 'СÂú',
//     age: 123
// };
// type protyKey<T> = T extends { name: infer U; age: infer U } ? U : T;
// type res = protyKey<typeof obj>; // type res = string | number

// inferµÄÄæ±ä
// type FnType<T> = T extends {
//     a: (args: infer U) => void;
//     b: (args: infer U) => void;
// }
//     ? U
//     : never;

// type T = FnType<{ a: (args: number) => void; b: (args: string) => void }>;

// 1.ÌáÈ¡Í·²¿ÔªËØ
// type Arr = ['a','b','c']
// type First<T extends any[]> =  T extends [infer First,...any[]] ? First : []
// type a = First<Arr> // type a = "a"

// 2.Ìáȡβ²¿ÔªËØ
// type Arr = ['a', 'b', 'c'];
// type Last<T extends any[]> = T extends [...any[], infer Last] ? Last : [];
// type c = Last<Arr>; // type c = "c"

// 3.ÌÞ³ýµÚÒ»¸öÔªËØ Shift
// type Arr = ['a', 'b', 'c'];
// type First<T extends any[]> = T extends [unknown, ...infer Rest] ? Rest : [];
// type a = First<Arr>; // type a = ["b", "c"]

// 4.ÌÞ³ýβ²¿ÔªËØ pop
// type Arr = ['a', 'b', 'c'];
// type First<T extends any[]> = T extends [...infer Rest, unknown] ? Rest : [];
// type a = First<Arr>; // type a = ["a", "b"]

// revesove
// type Arr = [1, 2, 3, 4];
// type ReveArr<T extends any[]> = T extends [infer First, ...infer rest]
//     ? [...ReveArr<rest>, First]
//     : T;
// type Res = ReveArr<Arr>; // type Res = [4, 3, 2, 1]

type User = {
    id: number;
    kind: string;
};

function makeCustomer<T extends User>(u: T): T {
    // Error£¨TS ±àÒëÆ÷°æ±¾£ºv4.4.2£©
    // Type '{ id: number; kind: string; }' is not assignable to type 'T'.
    // '{ id: number; kind: string; }' is assignable to the constraint of type 'T',
    // but 'T' could be instantiated with a different subtype of constraint 'User'.
    return {
        ...u,
        id: u.id,
        kind: 'customer'
    };
}