Пересечение типов в TypeScript
Типы пересечения объединяют несколько типов в новый тип, который включает типы всех членов.
Это похоже на множественное наследование в объектно-ориентированном программировании, позволяя типу иметь характеристики нескольких типов.
Диаграмма SVG: типы пересечения
Зачем нужны типы пересечения?
При разработке тип часто должен обладать характеристиками нескольких типов.
Например, сотрудник является и Person, и Worker, и должен обладать свойствами обоих.
Типы пересечения позволяют объединять несколько типов в один, удовлетворяя этому требованию.
Объяснение концепции:Типы пересечения используют
&символ для соединения нескольких типов, означающий, что новый тип содержит члены всех типов. Это похоже на концепцию множественного наследования.
Базовый синтаксис
Используйте&символ для объединения нескольких типов.
Пример
// Включает имя и возраст
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, ни одно не может отсутствовать.
Типы пересечения против наследования интерфейсов
Типы пересечения могут заменить множественное наследование интерфейсов.
Пример
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...}
Паттерн миксинов:Это мощный паттерн, который добавляет новую функциональность существующим классам, не изменяя их.
Типы пересечения против типов объединения
Следует обратить особое внимание на приоритет при комбинировании типов пересечения и типов объединения.
Пример
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, вызванных ненужными пересечениями.
Другие расширения