Расширенное использование Enum в TypeScript: больше, чем просто перечисление

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

Основы перечислений в TypeScript

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

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

const direction: Direction = Direction.Up;

В этом примере мы определяем перечисление Direction с четырьмя элементами: Up, Down, Left и Right. Мы можем присваивать эти значения переменным, обеспечивая безопасность типов и простой для понимания код.

Пример 1: Enum со строковыми значениями

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

enum Color {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE",
}

const color: Color = Color.Red;

В этом примере мы определяем перечисление Color с тремя элементами, каждому из которых присвоено строковое значение. Это позволяет нам представлять набор строковых констант и использовать их в нашем коде.

Пример 2: вычисляемые значения Enum

Перечисления в TypeScript также поддерживают вычисляемые значения. Это означает, что мы можем присваивать значения членам перечисления на основе вычислений или выражений. Давайте посмотрим на пример:

enum Size {
  Small = 1,
  Medium = 2,
  Large = 3,
  XLarge = Large * 2,
}

const size: Size = Size.XLarge;

В этом примере мы определяем перечисление Size с четырьмя элементами. Значение члена XLarge вычисляется путем умножения значения члена Large на 2. Это позволяет нам создавать динамические и гибкие значения перечисления.

Пример 3: перечисления как типы объединения

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

enum Shape {
  Circle,
  Rectangle,
  Triangle,
}

type Circle = {
  kind: Shape.Circle;
  radius: number;
};

type Rectangle = {
  kind: Shape.Rectangle;
  width: number;
  height: number;
};

type Triangle = {
  kind: Shape.Triangle;
  base: number;
  height: number;
};

type ShapeType = Circle | Rectangle | Triangle;

function calculateArea(shape: ShapeType): number {
  switch (shape.kind) {
    case Shape.Circle:
      return Math.PI * shape.radius ** 2;
    case Shape.Rectangle:
      return shape.width * shape.height;
    case Shape.Triangle:
      return (shape.base * shape.height) / 2;
  }
}

const circle: Circle = { kind: Shape.Circle, radius: 5 };
const rectangle: Rectangle = { kind: Shape.Rectangle, width: 3, height: 4 };
const triangle: Triangle = { kind: Shape.Triangle, base: 6, height: 8 };

console.log(calculateArea(circle)); // Output: 78.53981633974483
console.log(calculateArea(rectangle)); // Output: 12
console.log(calculateArea(triangle)); // Output: 24

В этом примере мы определяем перечисление Shape с тремя элементами. Затем мы создаем три типа Circle, Rectangle и Triangle, которые имеют свойство kind, представляющее соответствующую фигуру из перечисления. Эти типы объединены в тип объединения ShapeType.

Мы также определяем функцию calculateArea, которая вычисляет площадь на основе вида и свойств фигуры. Используя перечисления в качестве типов объединения, мы можем создавать гибкий и типобезопасный код, который обрабатывает различные варианты формы.

Перечисления в TypeScript предлагают больше, чем просто перечисления. При расширенном использовании мы можем назначать строковые значения, вычислять значения перечисления и использовать перечисления в качестве строительных блоков для типов объединения. Эти функции повышают гибкость и выразительность нашего кода, позволяя нам создавать более надежные и типобезопасные решения.

В этой статье мы рассмотрели расширенное использование перечислений в TypeScript на примерах кода. Мы увидели, как использовать перечисления со строковыми значениями, вычислять значения перечислений и использовать перечисления как типы объединения для повышения безопасности типов.

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

Удачного перечисления с TypeScript!