ts学习-基本类型与枚举类型

  // 原始类型
  let bool: boolean = true;
  let num: number = 123;
  let str: string = 'hello';
  // 数组
  let arr1: number[] = [1, 2, 3];
  let arr2: Array<number> = [1, 2, 3];
  let arr3: Array<number | string> = [1, 2, 3, '4'];
  // 元组
  let tuple: [number, string] = [0, '1'];
  tuple.push(2); // 可以添加
  tuple[2]; // 不能越界访问
  // 函数, 利用ts的类型推断，返回类型可省略
  let add = (x: number, y: number): number => x + y;
  let compute: (x: number, y: number) => number;
  compute = (a, b) => a + b;
  // 对象
  let obj: object = {x: 1, y: 2};
  obj.x = 3;// 不允许被修改
  let obj: {x: number, y: number} = {x: 1, y: 2};
  obj.x = 3;// 可以被修改
  // symbol
  let s1: symbol = Symbol();
  let s2 = Symbol();
  s1 === s2; // false
  // undefined, null, 不能被赋值为其他类型
  let un: undefined = undefined;
  let nu: null = null;
  // 设置配置项"strictNullChecks": false后
  // num = undefined 被允许
  // num = null 被允许
  // 联合类型
  let num: number | undefined | null = 123; 
  // void 操作符，没有任何返回值的类型
  let noReturn = () => {};
  void 0; // undefined
  // any，可以任意的给它赋值
  let x;
  // never，永远不会有返回值的类型
  let error = () => {
    throw new Error('error');
  }
  let endless = () => {
    while(true) {} // 死循环
  }

// 1.数字枚举
enum Role {
  Reporter = 1, // 定义值
  Developer,
  Maintainer,
  Owner,
  Guest
}
console.log(Role.Reporter); // 没定义值时为0, 后面的值依次递增
console.log(Role);
/* 实现原理：反向映射
  {
    1: "Reporter"
    2: "Developer"
    3: "Maintainer"
    4: "Owner"
    5: "Guest"
    Reporter: 1
    Developer: 2
    Maintainer: 3
    Owner: 4
    Guest: 5
  }
*/
// 2.字符串枚举
enum Message {
  Success = '恭喜你，成功了',
  Fail = '抱歉，失败了'
}
// 3.异构枚举 （数字和字符串混用，不建议使用）
enum Answer {
  N,
  Y = 'Yes'
}
console.log(Answer); // {0: "N", N: 0, Y: "Yes"}

// 枚举成员
Role.Reporter = 2; // 枚举成员不能被赋值
enum Char {
  // const 常量枚举成员
  a,
  b = Char.a,
  c = 1 + 3,
  // computed 非常量枚举成员，成员一定要被赋值
  d = Math.random(),
  e = '123'.length
}

// 常量枚举，编译后被移除
// 作用，不需要对象而需要对象的值时可以使用常量枚举，会减少在编译环境的代码
const enum Month {
  Jan,
  Feb,
  Mar
};
let month = [Month.Jan, Month.Feb, Month.Mar];

// 枚举类型
enum E {a, b};
enum F {a = 0, b = 1};
enum G {a = 'apple', b = 'banana'};

let e: E = 3;
let f: F = 3;
e === f; // 报错，不可以被比较

let e1: E.a = 1;
let e2: E.b;
e1 === e2; // 不可以被比较
let e3: E.a = 1;
e1 === e3; // 可以被比较

let g1: G = G.b;
let g2: G.a = G.a;

// 例子，角色判断
const enum ERole {
  role1 = 1,
  role2,
  role3,
  role4,
  role5
};
function initByRole(role: ERole) {
  switch (role) {
    case ERole.role1:
    case ERole.role2:
      // do sth
      console.log(111);
      break;
    case ERole.role3:
      // do sth
      console.log(222);
      break;
    case ERole.role4:
      // do sth
      console.log(333);
      break;
    case ERole.role5:
      // do sth
      console.log(444);
      break;
    default: break;
  }
}