Перечисления

В TypeScript enum — это набор именованных константных значений.

enum Color {
    Red = '#ff0000',
    Green = '#00ff00',
    Blue = '#0000ff',
}

Перечисления можно определять разными способами:

Числовые перечисления

В TypeScript числовое перечисление — это перечисление, в котором каждой константе присвоено числовое значение, по умолчанию начиная с 0.

enum Size {
    Small, // value starts from 0
    Medium,
    Large,
}

Можно задать пользовательские значения, присвоив их явно:

enum Size {
    Small = 10,
    Medium,
    Large,
}
console.log(Size.Medium); // 11

Строковые перечисления

В TypeScript строковое перечисление — это перечисление, в котором каждой константе присвоено строковое значение.

enum Language {
    English = 'EN',
    Spanish = 'ES',
}

Примечание: TypeScript позволяет использовать разнородные перечисления, в которых могут одновременно присутствовать строковые и числовые члены.

Константные перечисления

Константное перечисление в TypeScript — это особый вид перечисления, все значения которого известны во время компиляции и подставляются непосредственно в места использования, что делает код эффективнее.

const enum Language {
    English = 'EN',
    Spanish = 'ES',
}
console.log(Language.English);

Будет скомпилировано в:

console.log('EN' /* Language.English */);

Примечания: Значения константных перечислений жёстко заданы, а сами перечисления стираются из скомпилированного кода, что может быть эффективнее в автономных библиотеках, но в целом нежелательно. Кроме того, константные перечисления не могут содержать вычисляемые члены.

Обратное сопоставление

В TypeScript обратное сопоставление в перечислениях означает возможность получить имя члена перечисления по его значению. По умолчанию члены перечисления имеют прямое сопоставление имени со значением, однако обратное сопоставление можно создать, явно задав значения для каждого члена. Обратные сопоставления полезны, когда требуется найти член перечисления по его значению или перебрать все члены перечисления. Обратите внимание: обратные сопоставления создаются только для числовых членов перечисления, а для строковых членов они не создаются вовсе.

Следующее перечисление:

enum Grade {
    A = 90,
    B = 80,
    C = 70,
    F = 'fail',
}

Компилируется в:

'use strict';
var Grade;
(function (Grade) {
    Grade[(Grade['A'] = 90)] = 'A';
    Grade[(Grade['B'] = 80)] = 'B';
    Grade[(Grade['C'] = 70)] = 'C';
    Grade['F'] = 'fail';
})(Grade || (Grade = {}));

Таким образом, сопоставление значений с ключами работает для числовых членов перечисления, но не для строковых:

enum Grade {
    A = 90,
    B = 80,
    C = 70,
    F = 'fail',
}
const myGrade = Grade.A;
console.log(Grade[myGrade]); // A
console.log(Grade[90]); // A

const failGrade = Grade.F;
console.log(failGrade); // fail
console.log(Grade[failGrade]); // Element implicitly has an 'any' type because index expression is not of type 'number'.

Внешние перечисления

Внешнее перечисление в TypeScript — это вид перечисления, определённый в файле деклараций (*.d.ts) без связанной с ним реализации. Оно позволяет определить набор именованных констант, которые можно безопасно с точки зрения типов использовать в разных файлах без необходимости импортировать детали реализации в каждый файл.

Вычисляемые и константные члены

В TypeScript вычисляемый член — это член перечисления, значение которого вычисляется во время выполнения, тогда как константный член — это член, значение которого задаётся во время компиляции и не может быть изменено во время выполнения. Вычисляемые члены разрешены в обычных перечислениях, а константные — как в обычных, так и в константных перечислениях.

// Constant members
enum Color {
    Red = 1,
    Green = 5,
    Blue = Red + Green,
}
console.log(Color.Blue); // 6 generation at compilation time

// Computed members
enum Color {
    Red = 1,
    Green = Math.pow(2, 2),
    Blue = Math.floor(Math.random() * 3) + 1,
}
console.log(Color.Blue); // random number generated at run time

Перечисления представлены объединениями, состоящими из типов их членов. Значения каждого члена могут определяться константными или неконстантными выражениями, при этом членам с константными значениями назначаются литеральные типы. Для примера рассмотрим объявление типа E и его подтипов E.A, E.B и E.C. В данном случае E представляет объединение E.A | E.B | E.C.

const identity = (value: number) => value;

enum E {
    A = 2 * 5, // Numeric literal
    B = 'bar', // String literal
    C = identity(42), // Opaque computed
}

console.log(E.C); //42