【TypeScript】初步了解枚举

TypeScript 初步了解枚举

理解：枚举是列举固定几个值,直接定义变量的话的话可以随意定义，枚举只能使用你定义好的几个值。使用枚举我们可以定义一些带名字的常量，TypeScript支持数字的和基于字符串的枚举

使用了枚举，别人只能传你枚举类里定义好的几个类型，传其它的就会在编译时期报错

数字枚举

我们定义了一个数字枚举， Up使用初始化为 1。 其余的成员会从 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 a(b: string, message: response): void {
  // ...
}

a("test", response.Yes)

下面的情况不被允许的:

enum E {
  A = getSomeValue(),
  B // error! 'A' is not constant-initialized, so 'B' needs an initializer
}

原因： 由于getSomeValue()不是一个初始常量(到运行时才能确定的值就不是constant值了),所以此时需要给B初始值

字符串枚举：

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

enum a {
  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' }