02. 简单基础类型：
string number boolean symbol 
注意与 String Number Boolean Symbol的区别（一般用不到）。
var a: String = new String('123');
var a:string = '123';

03. 复杂基础类型：
// 这里需要注意：数组类型的值只有显示添加了元组类型注解后（或者使用 as const，声明为只读元组），
// TypeScript 才会把它当作元组，否则推荐出来的类型就是普通的数组类型

1. 接口类型
ts会将对象字面量和变量区别对待，如下示例：
function someMethod(params: { name: 'string' }){...}
// ① 报错 存在多余age字段
someMethod({ name: 'xx', age: 2 });
// ② ok
const params = { name: 'xx', age: 2 };
someMethod(params);// 类型只要兼容 即可

接口定义方法：
interface ITestFuncion {
  (params: ISomeType): void;
}
const someTestFunc:ITestFuncion = (params) => {...};
不过一般不用上面的方式定义方法类型，一般用type或者内联的方式。

只读属性:
interface ITest {
  readonly name: string;
}

索引签名：
interface ITest {
  [key: string]: string;
}
索引签名的限制：具名属性的类型需要是索引签名类型的同类型或者兼容的子类型。
特殊性：数字索引字段可以与 [key: string] 类型的索引兼容。即如下示例是ok的：
const someObj: ITest = { 1: 'xxx' };

接口继承：
interface A extends B {...}
接口实现：
class A implements B {...}


2.类型别名
将部分定义抽离出来，可以进行复用。
type A = number | string;

总结：
大部分情况下，interface和type是等价的，但是同时定义同名interface或type时，表现会有差异。
{
  interface A { id: number; }
  interface A { name: string; }
  const a: A = { id: 123, name: 'xxx' }; // ok
  // 利用这个特性 公共库的定义文件 我们可以很方便的进行扩展
}
{
  type A = { id: number; }
  // ts报错
  type A  = { name: string; }
}


3. 联合类型（union）和交叉类型（intersection）
可以帮助我们进行类型抽离，公共类型的复用。

联合（满足C或D即可）：
type A = C | D
交叉（同时满足C和D）：
type A = C & D

当存在同名属性时，联合和交叉类型都会进行类型缩减，不同的是联合类型会往大里扩展，交叉类型会往小里扩展。
tips：never类型是所有类型的子类型。

合并联合类型（实际是取交集）：
type UnionA = 'px' | 'em' | 'rem' | '%';
type UnionB = 'vh' | 'em' | 'rem' | 'pt';
type IntersectionUnion = UnionA & UnionB;

🌰：
type BorderColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | string; // 类型缩减成 string 字符串字面量 black、red 等都无法自动提示出来
type BorderColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | string & {}; // 字面类型都被保留（ ts的黑魔法）这样IDE可以正常提示了


4. 枚举类型
定义命名常量集合。
7 种常见的枚举类型：数字类型、字符串类型、异构类型、常量成员和计算（值）成员、枚举成员类型和联合枚举、常量枚举、外部枚举
// 默认不指定其他类型值既是数字类型
enum TypeEnum {
  A, // 默认从0开始递增
  B,
}
// 字符串类型
enum TypeEnum {
  A = 'A', 
  B = 'B',
}
// 异构类型：基本不这么用
enum TypeEnum {
  A = 'A', 
  B = 2
}
// 常量成员和计算成员: 很难用到
在前边示例中，涉及的枚举成员的值都是字符串、数字字面量和未指定初始值从 0 递增数字常量，都被称作常量成员。
另外，在转译时，通过被计算的常量枚举表达式定义值的成员，也被称作常量成员。
enum SomeEnum {
    // 常量成员
    None,
    Read = 1 << 1,
    Write = 1 << 2,
    ReadWrite = Read | Write,
    // 计算成员
    G = "123".length,
  }

// 外部枚举
declare enum Day {
  SUNDAY,
  MONDAY,
}
const work = (x: Day) => {
  if (x === Day.SUNDAY) {
    x; // 类型是 Day
  }
}
// declare enum 定义的枚举转化成js后 声明移除，但是引用未被转换 代码如下
const work = (x) => {
  if (x === Day.SUNDAY) {
    x;
  }
}
// 但使用declare const enum
declare const enum Day {
  SUNDAY,
  MONDAY,
}
const work = (x: Day) => {
  if (x === Day.SUNDAY) {
    x; // 类型是 Day
  }
}
// declare const enum 定义的枚举转化成js后 声明移除 表现同常规枚举定义（内联枚举值）
const work = (x) => {
  if (x === 0) {
    x;
  }
}


5. 泛型
什么是泛型：泛型指的是类型参数化，即将原来某种具体的类型进行参数化。
和定义函数参数一样，我们可以给泛型定义若干个类型参数，并在调用时给泛型传入明确的类型参数。
设计泛型的目的在于有效约束类型成员之间的关系，比如函数参数和返回值、类或者接口成员和方法之间的关系。
函数的泛型入参必须和参数/参数成员建立有效的约束关系才有实际意义.
function uselessGenerics<P>(): P {
  return void 0 as unknown as P; // 无意义
}
// react 组件也支持泛型
function SomeCom<P>(props:P) {
  return <></>;
};
<SomeCom<{ name: string; }> name="1" ... />

// 泛型支持运算：
type StringOrNumberArray<E> = E extends string | number ? E[] : E;
type BooleanOrString = string | boolean;
// 鼠标hover到WhatIsThis上，显示boolean | string[]，因为分配条件类型：
// 关于分配条件类型这个概念，官方的释义：在条件类型判断的情况下（比如示例中出现的 extends）
// 如果入参是联合类型，则会被拆解成一个个独立的（原子）类型（成员）进行类型运算。
type WhatIsThis = StringOrNumberArray<BooleanOrString>; //  boolean | string[]
// 这里BooleanOrString 不是一个泛型，不会拆解（你可以理解他就是一个类型，所以返回他自己）
type BooleanOrStringGot = BooleanOrString extends string | number
  ? BooleanOrString[]
  : BooleanOrString; //  string | boolean

// 泛型约束：将泛型约束在特定的类型范围内
function reflectSpecified<P extends number | string | boolean>(param: P):P {
  return param;
}
// 给泛型指定默认值
interface IProps<State = { id: number; name: string }> {
  state: State
}
// 组合
interface IProps<State extends {} = { id: number; name: string }> {
  state: State
}