枚举

    这些枚举类型的值都是数字类型，因此它们被称为数字类型枚举。

    数字类型枚举，允许我们将数字类型或者其他任何与数字类型兼容的类型赋值给枚举类型的实例。

    2.   Red,
    3.   Green,
    4.   Blue
    5. }
    7. let col = Color.Red;
    8. col = 0; // 有效的，这也是 Color.Red

    数字类型枚举与字符串类型

    在我们继续深入枚举类型之前，先让我们看看它编译的 JavaScript，以下是一个简单的 TypeScript 枚举类型：

    1. enum Tristate {
    2.   False,
    3.   True,
    4.   Unknow
    5. }

    编译成 JavaScript：

    1. var Tristate;
    2. (function(Tristate) {
    3.   Tristate[(Tristate['False'] = 0)] = 'False';
    4.   Tristate[(Tristate['True'] = 1)] = 'True';
    5.   Tristate[(Tristate['Unknown'] = 2)] = 'Unknown';
    6. })(Tristate || (Tristate = {}));

    先让我们聚焦于代码高亮的一行，其中 Tristate['False'] = 0 用于自我解释，例如将 Tristate 对象里的 False 成员值设置为 0。注意，JavaScript 赋值运算符返回的值是被赋予的值（在此例子中是 0），因此下一次 JavaScript 运行时执行的代码是 Tristate[0] = 'False'。意味着你可以使用 Tristate 变量来把字符串枚举类型改造成一个数字或者是数字类型的枚举类型，如下所示：

    1. enum Tristate {
    2.   False,
    3.   True,
    4.   Unkown
    5. }
    7. console.log(Tristate[0]); // 'False'
    8. console.log(Tristate['False']); // 0
    9. console.log(Tristate[Tristate.False]); // 'False' because `Tristate.False == 0`

    默认情况下，第一个枚举值是 0，然后每个后续值依次递增 1：

    1. enum Color {
    2.   Red, // 0
    3.   Green, // 1
    4.   Blue // 2
    5. }

    但是，你可以通过特定的赋值来改变给任何枚举成员关联的数字，如下例子，我们从 3 开始依次递增：

    TIP

    我通常用 = 1 初始化，因为在枚举类型值里，它能让你做一个安全可靠的检查。

    使用数字类型作为标志

    1. enum AnimalFlags {
    2.   None        = 0,
    3.   HasClaws    = 1 << 0,
    4.   CanFly      = 1 << 1,
    5.   EatsFish    = 1 << 2,
    6.   Endangered  = 1 << 3
    7. }

    在这里，我们使用了左移的位运算符，将数字 1 的二进制向左移动位置得到数字 0001、0010、0100 和 1000（换成十进制结果是：1, 2, 4, 8）。当你在使用这边标记的时候，这些位运算符 | (或)、& （和）、~ （非）将会是你最好的朋友：

    1. enum AnimalFlags {
    2.   None        = 0,
    3.   HasClaws    = 1 << 0,
    4.   CanFly      = 1 << 1
    7.   flags: AnimalFlags;
    8.   [key: string]: any;
    9. }
    11. function printAnimalAbilities(animal: Animal) {
    12.   var animalFlags = animal.flags;
    13.   if (animalFlags & AnimalFlags.HasClaws) {
    14.     console.log('animal has claws');
    15.   }
    16.   if (animalFlags & AnimalFlags.CanFly) {
    17.     console.log('animal can fly');
    18.   }
    19.   if (animalFlags == AnimalFlags.None) {
    20.     console.log('nothing');
    21.   }
    22. }
    24. var animal = { flags: AnimalFlags.None };
    25. printAnimalAbilities(animal); // nothing
    26. animal.flags |= AnimalFlags.HasClaws;
    27. printAnimalAbilities(animal); // animal has claws
    28. animal.flags &= ~AnimalFlags.HasClaws;
    29. printAnimalAbilities(animal); // nothing
    30. animal.flags |= AnimalFlags.HasClaws | AnimalFlags.CanFly;
    31. printAnimalAbilities(animal); // animal has claws, animal can fly

    在这里：

    • 我们使用 |= 来添加一个标志；
    • 组合使用 &= 和 ~ 来清理一个标志；
    • | 来合并标志。

    TIP

    你可以组合标志，用来在枚举类型中定义方便快捷的方式，如下 EndangeredFlyingClawedFishEating：

    1. enum AnimalFlags {
    2.   None        = 0,
    3.   HasClaws    = 1 << 0,
    4.   CanFly      = 1 << 1,
    6.   EndangeredFlyingClawedFishEating = HasClaws | CanFly | EatsFish | Endangered
    7. }

    在上文中，我们只看到了数字类型的枚举，实际上，枚举类型的值，也可以是字符串类型。

    1. export enum EvidenceTypeEnum {
    2.   UNKNOWN = '',
    3.   PASSPORT_VISA = 'passport_visa',
    4.   PASSPORT = 'passport',
    5.   SIGHTED_STUDENT_CARD = 'sighted_tertiary_edu_id',
    6.   SIGHTED_KEYPASS_CARD = 'sighted_keypass_card',
    7.   SIGHTED_PROOF_OF_AGE_CARD = 'sighted_proof_of_age_card'
    8. }

    这些可以更容易被处理和调试，因为它们提供有意义/可调试的字符串。

    你可以使用它们用于简单的字符串比较：

    1. // Where `someStringFromBackend` will be '' | 'passport_visa' | 'passport' ... etc.
    2. const value = someStringFromBackend as EvidenceTypeEnum;
    4. // Sample use in code
    5. if (value === EvidenceTypeEnum.PASSPORT) {
    6.   console.log('You provided a passport');
    7.   console.log(value); // `passport`
    8. }

    常量枚举

    const lie = Tristate.False 编译成 JavaScript let lie = Tristate.False (是的，编译后与编译前，几乎相同)。这意味着在运行执行时，它将会查找变量 Tristate 和 Tristate.False。在此处获得性能提升的一个小技巧是使用常量枚举：

    1.   False,
    2.   True,
    3.   Unknown
    4. }
    6. const lie = Tristate.False;

    将会被编译成：

    1. let lie = 0;
    • 内联枚举的任何用法（0 而不是 Tristate.False）；
    • 不会为枚举类型编译成任何 JavaScript（在这个例子中，运行时没有 Tristate 变量），因为它使用内联语法。

    使用内联语法对性能有明显的提升作用。运行时没有 Tristate 变量的事实，是因为编译器帮助你把一些在运行时没有用到的不编译成 JavaScript。然而，你可能想让编译器仍然把枚举类型编译成 JavaScript，用于如上例子中从字符串到数字，或者是从数字到字符串的查找。在这种情景下，你可以使用编译选项 —preserveConstEnums，它会编译出 var Tristate 的定义，因此你在运行时，手动使用 Tristate['False'] 和 Tristate[0]。并且这不会以任何方式影响内联。

    你可以使用 enum + namespace 的声明的方式向枚举类型添加静态方法。如下例所示，我们将静态成员 isBusinessDay 添加到枚举上：

    1. enum Weekday {
    2.   Monday,
    3.   Tuseday,
    4.   Wednesday,
    5.   Thursday,
    6.   Friday,
    7.   Saturday,
    8.   Sunday
    9. }
    11. namespace Weekday {
    12.   export function isBusinessDay(day: Weekday) {
    13.     switch (day) {
    14.       case Weekday.Saturday:
    15.       case Weekday.Sunday:
    16.         return false;
    17.       default:
    18.         return true;
    19.     }
    20.   }
    21. }
    23. const mon = Weekday.Monday;
    24. const sun = Weekday.Sunday;
    26. console.log(Weekday.isBusinessDay(mon)); // true
    27. console.log(Weekday.isBusinessDay(sun));

    开放式枚举

    TIP

    你只有在不使用模块时，开放式的枚举才有意义，你应该使用模块，因此这部分在文章最后。

    让我们再一次看看编译成 JavaScript 的枚举是什么样子：

    1. var Tristate;
    2. (function(Tristate) {
    3.   Tristate[(Tristate['False'] = 0)] = 'False';
    4.   Tristate[(Tristate['True'] = 1)] = 'True';
    5.   Tristate[(Tristate['Unknown'] = 2)] = 'Unknown';
    6. })(Tristate || (Tristate = {}));

    我们已经解释了 Tristate[Tristate['False'] = 0] = 'False' 部分，现在我们来看看包裹函数 (function (Tristate) { / code here /})(Tristate || (Tristate = {}))，特别是 (Tristate || (Tristate = {})) 部分。这捕获了一个局部变量 TriState，它将指向已经定义的 TriState 或者是使用一个新的控对象初始化它。

    这意味着你可以跨多个文件拆分（和扩展）枚举定义，如下所示，你可以把 Color 的定义拆分至两个块中：

    1. enum Color {
    2.   Red,
    3.   Green,
    4.   Blue
    5. }
    7. enum Color {
    8.   DarkRed = 3,
    9.   DarkGreen,
    10.   DarkBlue

    TIP

    你应该在枚举的延续块中，初始化第一个成员，以便生成的代码不是先前定义的枚举类型值。TypeScript 将会发出警告，如果你定义初始值（错误信息：In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.）。