可以定义一些带名字的常量，暂时只支持数字的和基于字符串的枚举。

一、枚举

1，数字枚举

会从0自增

  1. enum Direction {
  2.     Up, // 输出0 // 从0开始自增
  3.     Down, // 输出1
  4.     Left = 3, // 输出3 // 赋值
  5.     Right, // 输出4 // 赋值后自增
  6. }
  8. function respond(recipient: string, message: Direction): void { // 枚举可以作为类型
  9.     // ...
  10. }
  12. respond("Princess Caroline", Direction.Down) // 枚举也可以直接读取

没有初始化器的成员要么在首位，要么必须在用数值常量或其他常量枚举成员初始化的数值枚举之后

  1. enum E {
  2.     A = getSomeValue(),
  3.     B, // 出错，没有初始化的数字枚举要么在首位，要么必须在用数值常量或其他常量枚举成员初始化的数值枚举之后
  4. }

2，字符串枚举

  1. // 由于字符串没有自增的肯可能，所以申明时，必须初始化
  2. enum Direction {
  3.     Up = "UP",
  4.     Down = "DOWN",
  5.     Left = "LEFT",
  6.     Right = "RIGHT",
  7. }

3，异构枚举

  1. // 混合字符串和枚举，用的少
  2. enum BooleanLikeHeterogeneousEnum {
  3.     No = 0,
  4.     Yes = "YES",
  5. }

4，计算的和常量成员

  1. // 常量枚举申明方式有：
  3. // 类型1：没有初始化值的
  4. enum E { X } // X=0
  6. //类型2：枚举成员是数字
  7. enum E2 {
  8.     A = 1, B, C // B=2, C=3
  9. }
  11. //类型3：常量枚举表达式 // 若常量枚举表达式求值后为 NaN 或 Infinity ，则会在编译阶段报错。
  12. enum FileAccess {
  13.     // constant members
  14.     None,
  15.     Read    = 1 + 1,
  16.     Write   = 1 % 2,
  17.     ReadWrite  = Read | Write,
  18.     // computed member
  19.     G = "123".length
  20. }

5，联合枚举与枚举成员的类型

字面量枚举成员（非计算的常量枚举成员的子集）的枚举成员成为了类型，并且本身变成了每个枚举成员的联合

  1. // 1，枚举成员成为了类型
  2. enum ShapeKind {
  3.     Circle,
  4.     Square,
  5. }
  6. interface Circle {
  7.     kind: ShapeKind.Circle;
  8.     radius: number;
  9. }
  10. interface Square {
  11.     kind: ShapeKind.Square;
  12.     sideLength: number;
  13. }
  14. let c: Circle = {
  15.     kind: ShapeKind.Square, // 错误，ShapeKind.Square类型不是ShapeKind.Circle类型
  16.     radius: 100,
  17. }
  19. // 2，本身变成了每个枚举成员的联合
  20. enum E {
  21.     Foo,
  22.     Bar,
  23. }
  24. function f(x: E) {
  25.     if (x !== E.Foo || x !== E.Bar) {
  26.         //             ~~~~~~~~~~~
  27.         // 出错 既然申明了参数为类型E，那么x只能从E类型中获取，E变成了一个联合类型
  28.     }
  29. }

6，运行时的枚举

枚举可以是类型，也可以是真正存在的对象

  1. enum E {
  2.     X, Y, Z
  3. }
  5. function f(obj: { X: number }) {
  6.     return obj.X;
  7. }
  9. // 没问题，因为 'E'包含一个数值型属性'X'。
  10. f(E);

7，编译时的枚举

  1. enum LogLevel {
  2.     ERROR, WARN, INFO, DEBUG
  3. }
  5. /**
  6.  * 等同于：
  7.  * type LogLevelStrings = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
  8.  */
  9. type LogLevelStrings = keyof typeof LogLevel; // 使用 keyof typeof 来获取一个表示枚举里所有字符串 key 的类型，而不是keyof
  11. function printImportant(key: LogLevelStrings, message: string) {
  12.     const num = LogLevel[key];
  13.     if (num <= LogLevel.WARN) {
  14.        console.log('Log level key is: ', key);
  15.        console.log('Log level value is: ', num);
  16.        console.log('Log level message is: ', message);
  17.     }
  18. }
  19. printImportant('ERROR', 'This is a message');
  1. // 反向映射
  2. enum Enum {
  3.     A
  4. }
  5. let a = Enum.A;
  6. let nameOfA = Enum[a]; // "A"
  9. // 相当于
  10. var Enum;
  11. (function (Enum) {
  12.     Enum[Enum["A"] = 0] = "A";
  13. })(Enum || (Enum = {}));
  14. var a = Enum.A;
  15. var nameOfA = Enum[a]; // "A"
  1. // 常量枚举
  2. const enum Directions {
  3.     Up,
  4.     Down,
  5.     Left,
  6.     Right
  7. }
  9. let directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right]
  11. // 编译后生成
  12. var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];

二、外部枚举

  1. // 普通枚举
  2. enum Students{weizexu,weixinyao,lizhihao};
  3. console.log(Students.lizhihao);  // 2
  5. // 外部枚举
  6. declare enum Students{weizexu,weixinyao,lizhihao};
  7. console.log(Students.lizhihao);  // Students is not defined