2021-12-17：类型浅谈

any

  any 可赋值任何类型，同时相当于被 TS 抛弃，传值不会进行类型检测，尽量避免使用该属性

  let a: any = 1;
  let b: number = 2;
  a = '1'

以上赋值为合法，TS不会进行检测

unknown

  特殊情况下，我们不知道该变量准确类型该怎么办？此时 TS 提供 unknown 让开发者使用，与 any 相同，可赋值任何类型，不同之处 TS 对unknown类型进行检测

  let a: unknown = 1;
  let b: number = 2;
  let c = a + b;  // => 运算符 “+” 不能应用于类型 “unknown” 和 "number"
  if(typeof a === 'number') {
    // 判断出 a 具体类型之后 我们可以编写对应事件
    let c = a + b;
  }

boolean

  boolean 拥有两个值：true和false。

  let a: boolean = true;
  let b: boolean = false;
  let c: true = true;
  let d: false = false;
  let e:true = false;   // => 不能将类型"false"分配给类型"true"

number

  包括所有数字：整数、浮点数、正数、负数

  let a: number = 1;
  let b: number = 1.1;
  let c: number = -1;
  let d: 1 = 1;

string

  包含所有字符串以及对字符串执行的操作

  let a: string = 'Hello';
  let b: string = 'TS';
  let c:string = a + b;
  let d: 'World' = 'World' 

对象

  最好使用 {} 用来定义对象属性

  let a: object = {
    b: 'b'
  }
  a.b // => 类型"object"上不存在属性"b"

object对值知之甚少，只能用来表示是一个JavaScript对象

  let a: {b: string} = {
    b: 'b'
  }
  a.b

此时就可以正常运行,此方法称为对象字面量，不是以往的类型字面量

• 对象字面量

常用写法与 ?

    let a: {
    a: number,
    b: string,
    // 参数可传可不传 使用 ？
    c?: boolean,
    // 键值对形式
    [key: number]:boolean
  } = {
    a: 1,
    b: '1',
    2: true,
    e: true // => 报错，对象中未定义该类型
  }

readonly 只读属性

  let a: {
    readonly name: string
  } = {
    name: 'zhangsan'
  }

  a.name = 'lisi' // => 无法分配到 "name" ,因为它是只读属性

类型别名

• type

类型别名有助于减少重复属于复杂类型

  type Person = {
    name: string,
    age: number
  }

  let drive: Person = {
    name: 'zhangsan',
    age: 12,
    skills: zero  // => 不能将类型分配到 Person
  }

• 并集类型和交集类型

  // 喵喵叫的猫猫
  type Cat = {name: string, meow: boolean};
  // 汪汪叫的狗狗 摇尾巴
  type Dog = {name: string, wang: boolean, wag: boolean}
  // 并集 两者内容之和
  type CatOrDog = Cat | Dog;

  // 猫猫
  let a: CatOrDog = {
    name: 'Tom',
    meow: true
  }
  // 狗狗
  let b: CatOrDog = {
    name: 'WangCai',
    wang: true,
    wag: true
  }
  // 两者都有
  let c: CatOrDog = {
    name: 'Supper',
    meow: true,
    wang: true,
    wag: true
  }

并集不一定属于某个成员，可以同时拥有每个成员

注意：若并集不相交，只能属于并集类型中的某个成员

  // 喵喵叫的猫猫
  type Cat = {name: string, meow: boolean};
  // 汪汪叫的狗狗 摇尾巴
  type Dog = {name: string, wang: boolean, wag: boolean}
  // 交集 两者共同部分
  type CatAndDong = Cat & Dog;

 let a: CatAndDong = {
   name: 'Tom',
   meow: true,
   wang: true,
   wag: true
  }

超级 Tom 拥有所有技能

数组

• 元组

元组是 array 子类型，必须显示注解，长度固定、各索引值均有已知类型

  // ? 可传可不传
  let a: [number, string, boolean?, ] = [ 1, '1']

  // ... 剩余参数,可不传 可传多个
  let b: [string, ...number[]] = [ '1', 1, 2 ]

  // 只读数组 .concat .slice 可更改
  let c: readonly number[] = [ 1, 2, 3 ]
  c[2] = 5  // 类型 "readonly number[]" 中的值仅允许读取

  // 注解数组使用类型别名
  type d = readonly number[]
  let e: d = [ 1, 2, 3 ]

null、undefined、void、和never

• null

null 表示缺少值（例如：计算一个值的过程中遇到了错误）

// 一个返回数字或 null 的函数
function a(x: number) {
  if( x < 10 ) {
    return x
  }
  return null
}

• undefined

通常用来表示尚未赋值的变量

function b() {
  return undefined
}

• void

void 表示没有显示返回任何值时的类型

function c() {
  console.log('void');
}

• never

永远不会返回值（例如死循环）

function d() {
  while(true) {
  }
}

枚举

枚举的作用是列举类型中包含的各个值，按照约定，枚举名称为大写的单数形式，枚举中的键也为大写。

• 推导

// 若没有默认值，TS 自动为枚举中成员进行推导，从 0 开始推导
enum Language {
  Cat = 0,
  Dog = 1,
  Fish = 2
}
enum Languages {
  Cat,
  Dog,
  Fish
}
// 枚举中的值使用 点号 或者 中括号 进行访问，就像访问常规对象中的值
let animal = Language.Fish
let animals = Languages['Fish']

console.log(animal);  // => 2
console.log(animals); // => 2

• 多段声明

// 一个枚举可分成多段声明，TS自动把各部分合并一起，若分开声明，TS无法很好推导 Fish 推导为 0
enum Language {
  Cat = 0,
  Dog = 1
}
enum Language {
  Fish
}

let animal = Language.Fish

console.log(animal);  // => 0

• 混用字符

// 枚举的值也可以为字符串，甚至混用
enum Color {
  Red = '#c10000', 
  Blue = '#007ac1',
  Pink = 0xc10050,  // 十六进制字面量
  White = 255    // 十进制字面量
}

// 允许通过值访问，也允许通过键访问
let red = Color.Red;
let blue = Color[0];
// 下值不存在，TS 并不阻止我们这么做
let black = Color[5]

• const enum

// 枚举的值也可以为字符串，甚至混用
const enum Color {
  Red = '#c10000', 
  Blue = '#007ac1',
  Pink = 0xc10050,  // 十六进制字面量
  White = 255    // 十进制字面量
}

// 允许通过值访问，也允许通过键访问
let red = Color.Red;
let blue = Color[0];  // 报错：只有使用字符串文本才能访问常数枚举成员。

• const enum 不安全性

const enum Flippable {
  Burger,
  Chair,
  Cup,
  Skateboard,
  Table
}

const enum Flippables {
  Burger = 'Burger',
  Chair = 'Chair',
  Cup = 'Cup',
  Skateboard = 'Skateboard',
  Table = 'Table'
}
function flip(f: Flippable) {
  return 'flipper it'
}
function flips(f: Flippables) {
  return 'flippers it'
}
// 数字也可以赋值枚举，这是 TS 赋值规则导致的不良后果，使用字符串即可避免
flip(Flippable.Burger) // flip(Flippable.Burger)
flip(12) // flip(Flippable.Burger)
flips(12) // 报错：类型 12 不能赋值给 Flippables