TS的进阶

//用泛型 "保存" 索引类型 K extends keyof T
{
    /* 进阶: 用泛型保存索引类型
      K extends keyof T
     这里其实通过 extends 关键字来约束了 K 的类型
     */
    function pickValue<T, K extends keyof T>(obj: T, keys: K[]): T[K][] {
        return keys.map((key) => {
            return obj[key]
        })
    }

    interface Obj {
        name: string,
        age: number
    }

    const obj: Obj = {
        name: 'ss',
        age: 20
    }
    type Keys = keyof Obj;
    const keys: Keys[] = ['name', 'age']
    pickValue(obj, keys)
}
//使用 in 关键字来快速生成索引类型 [K in keyof T]: T[K]#
// 在需要对对象进行 for in/ for of 的场景下, 适合使用 in 关键字来定义一个索引类型, 从而快速生成一个索引类型.
{
    // 映射类型: Mapped Types
    // 从原有类型中映射出来的类型,
    // 由于要对类型中的 key 进行处理, 通常需要使用 in 操作符来遍历类型的索引 (key)
    //  [K in keyof T]: T[K]

    // example 某个克隆的类型
    type Clone<T> = {
        [K in keyof T]: T[K]
    }
    // 实现一些TS内部的映射类型
    type Partial<T> = {
        [K in keyof T]?: T[K]
    }
    type Readonly<T> = {
        readonly [K in keyof T]?: T[K]
    }
}
// 条件类型
// 使用 三元表达式 和 extends 关键字进行类型判断
{
    /* 条件类型: Conditional Types
 条件类型的语法其实就是三元表达式, 通常用于 通过对泛型进行判断来给出类型.
 泛型约束:
 对于类型无法即时确定的场景, 使用条件类型来在动态地确定最终的类型
 这样我们编写的函数被他人使用时, 就能根据他人使用时传入的参数来动态确定类型.
 注意事项: 何时条件类型系统可以收到足够的信息来确定类型.
 */

//  example1: 使用条件类型实现泛型约束的例子:
    declare function strOrNumber<T extends boolean>(X: T): T extends true ? string : number;

    const strReturnType = strOrNumber(true);
    const numReturnType = strOrNumber(false)

    // example2
    type TypeName<T> = T extends string
        ? "string" : T extends number
            ? "number" : T extends boolean
                ? "boolean" : T extends undefined
                    ? "undefined" : T extends Function
                        ? "function" : "object"

    type y = TypeName<"2"