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

Понимание общих ограничений:

Общие ограничения, также известные как ограничения типа, позволяют нам ограничить типы, которые могут использоваться в качестве аргументов в функции-конструкторе. Указывая эти ограничения, мы можем обеспечить определенный уровень совместимости и гарантировать правильное использование конструктора. Давайте углубимся в некоторые методы, которые можно использовать для достижения этой цели.

1. Используя ключевое слово extends:

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

class Box<T extends string | number> {
  constructor(private value: T) {}
}
const box1 = new Box("Hello"); // Valid
const box2 = new Box(42); // Valid
const box3 = new Box(true); // Invalid

В приведенном выше коде функция-конструктор Boxпринимает параметр типа T, который расширяет либо string, либо number. Поэтому передача логического значения в качестве аргумента приведет к ошибке компиляции.

2. Использование типов объединения:

Другой подход — использовать типы объединения в качестве общих ограничений. Это позволяет нам указать несколько возможных типов аргумента. Вот пример:

class Pair<T extends string | number> {
  constructor(private first: T, private second: T) {}
}
const pair1 = new Pair("Hello", "World"); // Valid
const pair2 = new Pair(42, 24); // Valid
const pair3 = new Pair(true, false); // Invalid

В приведенном выше коде функция-конструктор Pairпринимает два аргумента одного и того же типа T, которые должны быть либо string, либо number. Любой другой тип приведет к ошибке компиляции.

3. Использование защиты типов:

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

class Shape {
  constructor(private sides: number) {}
}
class Triangle extends Shape {
  constructor(private base: number, private height: number) {
    super(3);
  }
}
class Rectangle extends Shape {
  constructor(private width: number, private height: number) {
    super(4);
  }
}
function createShape<T extends Shape>(shape: T): T {
  if (shape instanceof Triangle && shape.base === shape.height) {
    throw new Error("Invalid triangle: base and height must be different.");
  }
  return shape;
}
const triangle = createShape(new Triangle(3, 4)); // Valid
const invalidTriangle = createShape(new Triangle(3, 3)); // Throws an error

В приведенном выше коде функция createShapeдействует как защита типа, которая проверяет и подтверждает форму, переданную в качестве аргумента. Если фигура является экземпляром Triangleс одинаковым основанием и высотой, выдается ошибка.

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

Итак, в следующий раз, когда вам понадобится более точный контроль над типами аргументов конструктора, не забудьте воспользоваться мощью общих ограничений!