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

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

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

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

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

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

enum Size {
    Small, // значение начинается с 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]); // Элемент неявно имеет тип 'any', поскольку индексное выражение не имеет тип 'number'.

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

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

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

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

// Константные члены
enum Color {
    Red = 1,
    Green = 5,
    Blue = Red + Green,
}
console.log(Color.Blue); // 6, вычисляется во время компиляции

// Вычисляемые члены
enum Color {
    Red = 1,
    Green = Math.pow(2, 2),
    Blue = Math.floor(Math.random() * 3) + 1,
}
console.log(Color.Blue); // случайное число, сгенерированное во время выполнения

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

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

enum E {
    A = 2 * 5, // Числовой литерал
    B = 'bar', // Строковый литерал
    C = identity(42), // Непрозрачное вычисляемое значение
}

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