Пересечение типов в TypeScript

Типы пересечения объединяют несколько типов в новый тип, который включает типы всех членов.

Это похоже на множественное наследование в объектно-ориентированном программировании, позволяя типу иметь характеристики нескольких типов.


Диаграмма SVG: типы пересечения Background Title How Intersection Types Work Type A Type A (Person) name: string age: number Plus Sign & Type B Type B (Worker) company: string salary: number Arrow Merge Intersection Type A & B (Employee) name: string age: number company: string salary: number Bottom Section: Use Cases Use Cases for Intersection Types Scenario 1 Type Composition Merge characteristics of multiple types Scenario 2 Mixin Pattern Combine functionality of multiple classes Scenario 3 Replace interface inheritance More concise type composition Arrow Marker

Зачем нужны типы пересечения?

При разработке тип часто должен обладать характеристиками нескольких типов.

Например, сотрудник является и Person, и Worker, и должен обладать свойствами обоих.

Типы пересечения позволяют объединять несколько типов в один, удовлетворяя этому требованию.

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


Базовый синтаксис

Используйте&символ для объединения нескольких типов.

Пример

// Определить тип Person
// Включает имя и возраст
interface Person {
    name: string;
    age: number;
}

// Определить тип Worker
// Включает название компании и зарплату
interface Worker {
    company: string;
    salary: number;
}

// Используйте тип пересечения, чтобы объединить два интерфейса
// Тип Employee имеет все свойства и Person, и Worker
type Employee = Person & Worker;

// Создайте объект, обладающий характеристиками обоих типов
var employee: Employee = {
    name: "Alice",
    age: 25,
    company: "Google",
    salary: 100000
};

console.log("Employee: " + JSON.stringify(employee));

Вывод:

员工: {"name":"Alice","age":25,"company":"Google","salary":100000}

Объяснение:Тип пересеченияA & Bозначает, что новый тип имеет все свойства как A, так и B, ни одно не может отсутствовать.


Типы пересечения против наследования интерфейсов

Типы пересечения могут заменить множественное наследование интерфейсов.

Пример

// Определите тип A
interface A {
    a: string;
}

// Определить тип B
interface B {
    b: число;
}

// Использовать интерфейс для наследования нескольких интерфейсов
// Нужно использовать extends для наследования нескольких интерфейсов
interface AB extends A, B {
    c: логическое значение;
}

// Использовать тип пересечения (более лаконично)
// Напрямую использовать символ & для комбинирования типов
type ABType = A & B & { c: boolean };

// Оба метода создают тип, содержащий все свойства
var obj: ABType = { a: "hello", b: 42, c: true };
console.log("Объект: " + JSON.stringify(obj));

Вывод:

对象: {"a":"hello","b":42,"c":true}

Сравнение:Типы пересечения более лаконичны, чем наследование интерфейсов, особенно когда нужно наследовать несколько типов и добавить дополнительные свойства.


Смешивание типов (паттерн Mixin)

Использование типов пересечения для реализации паттерна Mixin позволяет динамически комбинировать функциональность классов.

Пример

// Определить тип конструктора
// Принимает любые аргументы и возвращает объект
type Constructor = new (...args: any[]) => {};

// Миксин: добавить функциональность отметки времени
// Возвращает новый класс, который расширяет Base
function Timestamped<T extends Constructor>(Base: T) {
    return class extends Base {
        timestamp = Date.now();
    };
}

// Миксин: добавить функциональность сериализации
// Возвращает новый класс, который расширяет Base и включает метод serialize
function Serializable<T extends Constructor>(Base: T) {
    return class extends Base {
        serialize() {
            return JSON.stringify(this);
        }
    };
}

// Базовый класс пользователя
class User {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}

// Объединить миксины
// Создать класс пользователя с функциональностью отметки времени
var TimestampedUser = Timestamped(User);
// Создать класс пользователя с функциональностью сериализации
var SerializableUser = Serializable(User);
// Объединить два миксина
var FullUser = Serializable(Timestamped(User));

// Создать экземпляр и протестировать
var user = new FullUser("Alice");
console.log("Метка времени: " + user.timestamp);
console.log("Сериализация: " + user.serialize());

Вывод:

时间戳: 17134...
序列化: {"name":"Alice","timestamp":17134...}

Паттерн миксинов:Это мощный паттерн, который добавляет новую функциональность существующим классам, не изменяя их.


Типы пересечения против типов объединения

Следует обратить особое внимание на приоритет при комбинировании типов пересечения и типов объединения.

Пример

// Тип объединения: может быть string или number
type StringOrNumber = string | number;

// Тип пересечения: пересечение несовместимых типов
// string & number = never (нет типа, который одновременно является string и number)
type Both = string & number;

// Определяем три типа
type A = { a: string };
type B = { b: number };
type C = { c: boolean };

// Комбинируем тип объединения и тип пересечения
// (A | B) & C пересекает каждую ветвь типа объединения с C
type Combined = (A | B) & C;

// Фактический результат: { a: string; c: boolean } | { b: number; c: boolean }
// То есть либо A + C, либо B + C
var obj: Combined = { a: "hello", c: true };
console.log("Combined: " + JSON.stringify(obj));

Вывод:

组合: {"a":"hello","c":true}

Важно:Пересечение несовместимых типов приводит кneverтипу. Например,string & numberнедопустимо.


Практические типы пересечения

Типы пересечения часто используются для создания служебных типов для преобразования типов.

Пример

// Сопоставленный тип: сделать все свойства необязательными
// Перебрать все свойства T, добавить ?, чтобы сделать их необязательными
type Partial<T> = { [P in keyof T]?: T[P] };

// Сопоставленный тип: сделать все свойства обязательными
// Перебрать все свойства T, удалить ?, чтобы сделать их обязательными
type Required<T> = { [P in keyof T]-?: T[P] };

// Сопоставленный тип: сделать все свойства readonly
// Перебрать все свойства T, добавить readonly
type Readonly<T> = { readonly [P in keyof T]: T[P] };

// Определить интерфейс конфигурации
interface Config {
    host: string;
    port: number;
}

// Использовать служебные типы
var partialConfig: Partial<Config> = { host: "localhost" };
var requiredConfig: Required<Config> = { host: "localhost", port: 8080 };
var readonlyConfig: Readonly<Config> = { host: "localhost", port: 8080 };

console.log("Partial: " + JSON.stringify(partialConfig));
console.log("Required: " + JSON.stringify(requiredConfig));
console.log("Readonly: " + JSON.stringify(readonlyConfig));

Вывод:

部分: {"host":"localhost"}
必填: {"host":"localhost","port":8080}
只读: {"host":"localhost","port":8080}

Служебные типы:Стандартная библиотека TypeScript предоставляет множество служебных типов, основанных на типах пересечения и отображаемых типах, таких как Partial, Required, Readonly и т. д.


Примечания

  • Несовместимые типы:Пересечение несовместимых типов приводит к never
  • Приоритет:Типы объединения имеют более высокий приоритет, чем типы пересечения
  • Конфликты методов:Если два типа имеют методы с одинаковым именем, конфликты нужно обрабатывать вручную

Лучшие практики:Типы пересечения подходят для объединения нескольких интерфейсов или типов. Когда требуется множественное наследование, предпочитайте типы пересечения наследованию интерфейсов.


Итог

Типы пересечения — мощный инструмент композиции типов в TypeScript.

  • Синтаксис:Используйте&символ для соединения нескольких типов
  • Слияние:Новый тип содержит члены всех типов
  • Mixin:Можно использовать для реализации функциональной композиции для классов
  • never:Пересечение несовместимых типов приводит к типу never

Рекомендация:Разумное использование типов пересечения позволяет создавать гибкие композиции типов, но будьте осторожны, чтобы избежать типов never, вызванных ненужными пересечениями.


Другие расширения