TS基础

类型

1. JS的运行时类型 Boolean Number String undefind null Bigint Symbol ts都支持
2. 复杂类型** Class Array** 元组（ Tuple ） 接口（ Interface ）枚举（ Enum ）
3. 特殊类型
   1. 模板字面量定义类型

      let str: `#${string}` = '#str' // 匹配 # 开头的字符串

   2. never 代表不可达，比如函数抛异常的时候，返回值就是 never。
   3. void 代表空，可以是 undefined 或 never。
   4. any 是任意类型，任何类型都可以赋值给它，它也可以赋值给任何类型（除了 never）。
   5. unknown 是未知类型，任何类型都可以赋值给它，但是它不可以赋值给别的类型。
4. Type 和 interface的区别
   1. type可以 定义基本类型的别名 ，如 type myString = string
   2. interface可以 声明合并 ，这种情况下，如果是type的话，就会报 重复定义 的警告

• 用interface描述 数据结构 ，用type描述类型关系
• 类型层级 never - 1 | 2 | “3” - string - String - Object - any / unknow

类型运算

1. extends

   1. 条件判断 一般用于动态类型的判断

      type isString<T> = T extends string ? true : false;
      type res_False = isString<1> // false
      type res_True = isString<'1'> // true

   2. 对类型进行约束（第一个extends）

      type ExampleType<T extends string> = T extends "5" ? true : false
      type isFive = ExampleType<'4'> // false

2. infer

   type FirstType<Tuple extends unknown[]> = Tuple extends [infer T, ...infer rest] ? T : never; // 提取第一个的类型
   type res = FirstType<[string, number, boolean]>; // string 

3. 联合 | 交叉 &

   // 联合
   type NumberType = 1 | 2 | 3 | 4
   let one:NumberType = 5 // error: 不能将类型“5”分配给类型“NumberType”。
   
   // 交叉
   type NumOrStrType = { num: number } & { str: string }
   let foo: NumOrStrType = {
       num: 1,
       str: 'str'
   }

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

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

   in 是用于遍历联合类型的运算符。

   // 修改值
   type MapType<T> = {
       [key in keyof T]: [T[key]]
   }
   type res_Map = MapType<{ num: number, str: string }>
   //type res_Map = {
   //     num: [number];
   //     str: [string];
   // }
   
   // 修改索引
   type MapType<T> = {
       [key in keyof T as `my${key & string}`]: [T[key]]
   }
   type res_Map = MapType<{ num: number, str: string }>
   // type res_Map = {
   //     mynum: [number];
   //     mystr: [string];
   // }
   
   // 遍历
   type Ref<Props> = keyof Props
   type res_Union = Ref<{ ref?: undefined, props: string }> // type res_Union = "ref" | "props"

   & string操作

   因为索引类型（对象、class 等）可以用 string、number 和 symbol 作为 key，这里 keyof T 取出的索引就是 string | number | symbol 的联合类型，和 string 取交叉部分就只剩下 string 了。