ts枚举类

参考官方文档:https://www.tslang.cn/docs/handbook/enums.html

理解:枚举是列举固定几个值,直接定义变量的话的话可以随意定义，枚举只能使用你定义好的几个值,枚举是个类，定义的值是基本类型,类能有更多操作

    例如你定义一个方法接收一个参数，这个参数如果是int型，别人在调用你这个方法时可以传1或2等任意数字，虽然你告诉了同事，只能传0或1,
    如果你把参数定义成只能传某个类型，例如是个枚举类，那么别人只能传你枚举类里定义好的几个类型，传其它的就会在编译时期报错

 

数字枚举:

我们定义了一个数字枚举， Up使用初始化为 1。 其余的成员会从 1开始自动增长。 换句话说，Direction.Up的值为 1， Down为 2， Left为 3， Right为 4。

enum Direction { Up = 1, Down, Left, Right }

我们还可以完全不使用初始化器:现在， Up的值为 0， Down的值为 1等等。 当我们不在乎成员的值的时候，这种自增长的行为是很有用处的，但是要注意每个枚举成员的值都是不同的。

enum Direction { Up, Down, Left, Right, }

通过枚举的属性来访问枚举成员，和枚举的名字来访问枚举类型：

enum Response {
    No = 0,
    Yes = 1,
}

function respond(recipient: string, message: Response): void {
    // ...
}

respond("Princess Caroline", Response.Yes)

不带初始化器的枚举或者被放在第一的位置，或者被放在使用了数字常量或其它常量初始化了的枚举后面。 换句话说，下面的情况是不被允许的

enum E {
    A = getSomeValue(), 
    B, // error! 'A' is not constant-initialized, so 'B' needs an initializer
}
/*由于getSomeValue()不是一个初始常量(到运行时才能确定的值就不是constant值了),所以此时需要给B初始值*/

字符串枚举:

在一个字符串枚举里，每个成员都必须用字符串字面量，或另外一个字符串枚举成员进行初始化。

enum Direction {
    Up = "UP",
    Down = "DOWN",
    Left = "LEFT",
    Right = "RIGHT",
}

计算的和常量成员

// 以下所有枚举成员都是常量
enum E { X }
enum E1 { X, Y, Z }
enum E2 {
    A = 1, B, C
}

enum FileAccess {
    None,
    Read    = 1 << 1,
    Write   = 1 << 2,
    ReadWrite  = Read | Write,
    // computed member
    G = "123".length
}

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

当枚举成员成为了类型

enum ShapeKind {
    Circle,
    Square,
}

interface Circle {
    kind: ShapeKind.Circle;
    radius: number;
}

interface Square {
    kind: ShapeKind.Square;
    sideLength: number;
}

let c: Circle = {
    kind: ShapeKind.Square,
    //    ~~~~~~~~~~~~~~~~ Error!
    radius: 100,
}

当枚举类型本身变成了每个枚举成员的 联合
下面这个例子里，我们先检查 x是否不是 E.Foo。 如果通过了这个检查，然后 ||会发生短路效果， if语句体里的内容会被执行。 然而，这个检查没有通过，那么 x则 只能为 E.Foo，因此没理由再去检查它是否为 E.Bar。

enum E {
    Foo,
    Bar,
}

function f(x: E) {
    if (x !== E.Foo || x !== E.Bar) {
        //             ~~~~~~~~~~~
        // Error! Operator '!==' cannot be applied to types 'E.Foo' and 'E.Bar'.
    }
}

反向映射

enum Enum {
    A
}
let a = Enum.A;
let nameOfA = Enum[a]; // "A"

// 例如打印下Role 看看解雇
enum Role {
    Reporter = 1,
    Developer,
    Maintainer,
    Owner,
    Guest
} 

  

外部枚举

外部枚举用来描述已经存在的枚举类型的形状。

declare enum Enum {
    A = 1,
    B,
    C = 2
}

外部枚举和非外部枚举之间有一个重要的区别，在正常的枚举里，没有初始化方法的成员被当成常数成员。 对于非常数的外部枚举而言，没有初始化方法时被当做需要经过计算的。

 

总结:

1.成员不初始化的话,默认是从0开始自增
enum Enum {A,B,C }
console.log(Enum); // {0: "A",1: "B",2: "C",A: 0,B: 1,C: 2}

2.数字型的枚举可以映射,字符串类型的枚举是不可以映射的.
enum Enum {A,B}
enum Strs {A = 'apple',B = 'orange'}
console.log(Enum); // {0: "A",1: "B",A: 0,B: 1}
console.log(Strs ); // {A: "apple"B: "orange"}

3.第一个成员初始化赋值为3的话,后面的成员从3开始增长
enum Enum {A = 3,B,C}
console.log(Enum); // {3: 'A',4: 'B',5:'C', A: 3,B: 4,C: 5}

4.如果第n个成员初始化赋值为string类型,则n后面的成员要给初始值
enum Enum {A,B='apple',C}; // 此时C不初始化会报错  Enum member must have initializer

5.不建议数字枚举和字符串枚举混用
enum Enum {A,B='apple',C}; 这种是不建议的

6.常量枚举成员在编译阶段会被计算出结果,计算类枚举成员的值会被保留,只有到运行时才会被计算

7.const声明的枚举是常量枚举,会在编译阶段被移出,意味着编译后没有任何代码的
当不需要对象,但需要一个对象的值的时候使用常量枚举
const enum Month { Jan, Feb, Mar, Apr }
let month = [Month.Jan, Month.Feb, Month.Mar]; 
// 编译的结果Month 是没有产生任何代码的
var month = [0 /* Jan */, 1 /* Feb */, 2 /* Mar */];

8.枚举类型:
    ①.所有成员没有初始值       enum E { a, b }
    ②.所有成员初始值为数字     enum F { a = 0, b = 1 } 
    ③.所有成员初始值为字符串   enum G { a = 'apple', b = 'banana' }

    let e: E = 3, f: F = 4;
    let e1: E.a = 3, e2: E.b = 3, e3: E.a = 4;
    由于E和F是纯数字,所以可以把任意的number赋值给e和f.取值也可以超出枚举值  let e: E = 3 或 let e: E = E.a ;
    let g1:G = G.a, g2:G.b = G.b
    G的成员是字符串,只能是枚举成员的类型复制给g1和g2

    两种不同的枚举值是不可以比较的  
    e === f   // 报错:因为类型“E”和“F”没有重叠,所以只会返回false
    e1 === e2 // 报错 ...
    e1 === e3 // 正确
    g1 === g2 // 报错 ,因为“E.a”和“E.b”类型没有重叠,所以只会返回false