记不住的东西-ts

0. type interface

interface II {
  name:string,
  age:number
}
type b = keyof II // 'name' | 'age'
type c = II[keyof II] // number | string

1. 内置的快捷同态转化

type Partial<T> = { [P in keyof T]?: T[P] }    // 将一个map所有属性变为可选的
type Required<T> = { [P in keyof T]-?: T[P] }    // 将一个map所有属性变为必选的
type Readonly<T> = { readonly [P in keyof T]: T[P] }    // 将一个map所有属性变为只读的
type Mutable<T> = { -readonly [P in keyof T]: T[P] }    // ts标准库未包含，将一个map所有属性变为可写的

interface Fruit {
    readonly name: string
    size: number
}
type PF = Partial<Fruit>;    // PF.name既只读又可选，PF.size只可选

2. set 转换为 map类型的

type Record<K extends keyof any, T> = { [P in K]: T };

type Size = 'small' | 'default' | 'big';

type SizeMap = Record<Size, number>;

/*
转换出来如下
{
    small: number
    default: number
    big: number
}
 */

// 由于对 K extends keyof any => K extends number | string | symbol
// 这个时候的 K 就是一个由对应的key组成的一个可以迭代数据
// { [P in K]: T } 就是循环对象A 生成一个map类型的接口。注意不是 [P in keyof K]

3. 常见的keyof extends in 这几个关键字 用于type生成更多的类型

type c = 'a' | 'b' | 'c';

type b = {
  [key in c] : string
}

type m <K extends keyof any> = K // 强行要试一下 extends keyof any 。通过对比 b 与 m1 就可以推测出来这句话返回的其实也是 可以推测出来 K 其实就是 'a' | 'b' | 'c' ,类似于是c的定义

type m1 = {
  [key in m<c>]: string
}

1. in 用于对set类型的循环 不需要keyof去取key值

type cSet = 'a' | 'b';
type cMap<T> = {
  [key in cSet] : T
}

2. 通过keyof去获取 interface map类型的type的key值
type cMap1 = {
  a:string;
  b:number
}
type cMap2 = {
  readonly [K in keyof cMap1]:cMap1[K]
}

// 使用 extends keyof ** 可以取到一个类似于 'a' | 'b' | 'c' 这种类型的结构
// 只是说 对于 set类型的数据 取对应的key的话 需要使用  extends keyof any 
function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
    return o[name]; // o[name] is of type T[K]
}

4。 never实际应用。

// 保留set的一部分
type Extract<T, U> = T extends U ? T : never;

type Result = 1 | 2 | 3 | 'error' | 'success';
type StringResult = Extract<Result, string>;    // 'error' | 'success

//  删除set的一部分
type Exclude<T, U> = T extends U ? never : T;
type NumericResult = Exclude<Result, string>;    // 1 | 2 | 3

当一个值的类型为never的时候，会被删除掉

interface SomeProps {
    a: string
    b: number
    c: (e: MouseEvent) => void
    d: (e: TouchEvent) => void
}
// 如何得到 'c' | 'd' ？ 
// map 转换为 set
type GetKeyByValueType<T, Condition> = {
    [K in keyof T]: T[K] extends Condition ? K : never
} [keyof T]; // 这个地方自动去除了 never 类型的数据

type FunctionPropNames =  GetKeyByValueType<SomeProps, Function>;    // 'c' | 'd'

//分析结果如下
// 开始
{
    a: string
    b: number
    c: (e: MouseEvent) => void
    d: (e: TouchEvent) => void
}
// 第一步，条件映射
{
    a: never
    b: never
    c: 'c'
    d: 'd'
}
// 第二步，索引取值 
never | never | 'c' | 'd'
// never的性质
'c' | 'd'