Tipos de intersección de TypeScript
Los tipos de intersección (Intersection Types) combinan múltiples tipos en un nuevo tipo, y el nuevo tipo contiene los tipos de todos los miembros.
Esto es similar a la herencia múltiple en la programación orientada a objetos, lo que permite que un tipo tenga las características de varios tipos.
Diagrama SVG: Tipos de intersección
¿Por qué se necesitan los tipos de intersección?
En el desarrollo, un tipo a menudo necesita tener las características de múltiples tipos.
Por ejemplo, un empleado es tanto una persona (Person) como un trabajador (Worker), y necesita tener los atributos de ambos.
Los tipos de intersección nos permiten combinar múltiples tipos en uno solo, satisfaciendo esta necesidad.
Explicación del concepto:Los tipos de intersección usan
&el símbolo & para conectar múltiples tipos, lo que indica que el nuevo tipo contiene los miembros de todos los tipos. Esto es similar al concepto de herencia múltiple.
Sintaxis básica
Usar&el símbolo & para combinar múltiples tipos.
Ejemplo
// Incluye nombre y edad
interface Person {
name: string;
age: number;
}
// Definir el tipo de trabajador
// Incluye nombre de la empresa y salario
interface Worker {
company: string;
salary: number;
}
// Usar tipos de intersección para combinar dos interfaces
// El tipo Employee tiene todas las propiedades de Person y Worker al mismo tiempo
type Employee = Person & Worker;
// Crear un objeto que tenga las características de ambos tipos
var employee: Employee = {
name: "Alice",
age: 25,
company: "Google",
salary: 100000
};
console.log("Empleado: " + JSON.stringify(employee));
Resultado de ejecución:
员工: {"name":"Alice","age":25,"company":"Google","salary":100000}
Explicación:Tipo de intersección
A & Bsignifica que el nuevo tipo tiene todas las propiedades de A y B, y no puede faltar ninguna.
Tipos de intersección y herencia de interfaces
Los tipos de intersección pueden reemplazar la herencia múltiple de interfaces.
Ejemplo
interface A {
a: string;
}
// Definir el tipo B
interface B {
b: number;
}
// Usar herencia de interfaces para heredar múltiples interfaces
// Se necesita usar extends para heredar múltiples interfaces
interface AB extends A, B {
c: boolean;
}
// Usar tipos de intersección (más conciso)
// Usar directamente el símbolo & para combinar tipos
type ABType = A & B & { c: boolean };
// Ambas formas pueden crear un tipo que contenga todas las propiedades
var obj: ABType = { a: "hello", b: 42, c: true };
console.log("Objeto: " + JSON.stringify(obj));
Resultado de ejecución:
对象: {"a":"hello","b":42,"c":true}
Comparación:Los tipos de intersección son más concisos que la herencia de interfaces, especialmente cuando se necesita heredar múltiples tipos y agregar propiedades adicionales.
Mezcla de tipos (patrón Mixin)
Usar tipos de intersección para implementar el patrón Mixin permite combinar dinámicamente funcionalidades de clases.
Ejemplo
// Acepta cualquier parámetro y devuelve un objeto
type Constructor = new (...args: any[]) => {};
// Mixin: agregar funcionalidad de marca de tiempo
// Devuelve una nueva clase que extiende Base
function Timestamped<T extends Constructor>(Base: T) {
return class extends Base {
timestamp = Date.now();
};
}
// Mixin: agregar funcionalidad de serialización
// Devuelve una nueva clase que extiende Base, con un método serialize
function Serializable<T extends Constructor>(Base: T) {
return class extends Base {
serialize() {
return JSON.stringify(this);
}
};
}
// Clase de usuario base
class User {
name: string;
constructor(name: string) {
this.name = name;
}
}
// Combinar Mixins
// Crear una clase de usuario con funcionalidad de marca de tiempo
var TimestampedUser = Timestamped(User);
// Crear una clase de usuario con funcionalidad de serialización
var SerializableUser = Serializable(User);
// Combinar dos Mixins
var FullUser = Serializable(Timestamped(User));
// Crear una instancia y probar
var user = new FullUser("Alice");
console.log("Marca de tiempo: " + user.timestamp);
console.log("Serialización: " + user.serialize());
Resultado de ejecución:
时间戳: 17134...
序列化: {"name":"Alice","timestamp":17134...}
Patrón Mixin:Este es un patrón poderoso que puede agregar nuevas funcionalidades a una clase sin modificar la clase original.
Tipos de intersección y tipos de unión
Al combinar tipos de intersección y tipos de unión, se debe prestar especial atención a la prioridad.
Ejemplo
type StringOrNumber = string | number;
// Tipo de intersección: intersección de tipos incompatibles
// string & number = never (ningún tipo es a la vez cadena y número)
type Both = string & number;
// Definir tres tipos
type A = { a: string };
type B = { b: number };
type C = { c: boolean };
// Combinar tipos de unión y tipos de intersección
// (A | B) & C cruza cada rama del tipo de unión con C
type Combined = (A | B) & C;
// El resultado real es: { a: string; c: boolean } | { b: number; c: boolean }
// Es decir, o bien A + C, o bien B + C
var obj: Combined = { a: "hello", c: true };
console.log("Combinación: " + JSON.stringify(obj));
Resultado de ejecución:
组合: {"a":"hello","c":true}
Importante:La intersección de tipos incompatibles dará como resultado
neverel tipo never. Por ejemplo,string & numberstring & number no es válido.
Tipos de intersección útiles
Los tipos de intersección se utilizan a menudo para crear tipos utilitarios y realizar transformaciones de tipos.
Ejemplo
// Itera sobre todas las propiedades de T y agrega ? para hacerlas opcionales
type Partial<T> = { [P in keyof T]?: T[P] };
// Tipo mapeado: convierte todas las propiedades en obligatorias
// Itera sobre todas las propiedades de T y elimina ? para hacerlas obligatorias
type Required<T> = { [P in keyof T]-?: T[P] };
// Tipo mapeado: convierte todas las propiedades en de solo lectura
// Itera sobre todas las propiedades de T y agrega readonly
type Readonly<T> = { readonly [P in keyof T]: T[P] };
// Definir interfaz de configuración
interface Config {
host: string;
port: number;
}
// Usar tipos utilitarios
var partialConfig: Partial<Config> = { host: "localhost" };
var requiredConfig: Required<Config> = { host: "localhost", port: 8080 };
var readonlyConfig: Readonly<Config> = { host: "localhost", port: 8080 };
console.log("Parcial: " + JSON.stringify(partialConfig));
console.log("Requerido: " + JSON.stringify(requiredConfig));
console.log("Solo lectura: " + JSON.stringify(readonlyConfig));
Resultado de ejecución:
部分: {"host":"localhost"}
必填: {"host":"localhost","port":8080}
只读: {"host":"localhost","port":8080}
Tipos utilitarios:La biblioteca estándar de TypeScript proporciona muchos tipos utilitarios basados en tipos de intersección y tipos mapeados, como Partial, Required, Readonly, etc.
Precauciones
- Tipos incompatibles:La intersección de tipos incompatibles dará como resultado never
- Prioridad:La prioridad de los tipos de unión es mayor que la de los tipos de intersección
- Conflicto de métodos:Si dos tipos tienen métodos con el mismo nombre, es necesario manejar los conflictos manualmente.
Mejores prácticas:Los tipos de intersección son adecuados para combinar múltiples interfaces o tipos. Cuando se necesita herencia múltiple, es preferible usar tipos de intersección en lugar de herencia de interfaces.
Resumen
Los tipos de intersección son una poderosa herramienta de composición de tipos en TypeScript.
- Sintaxis:Uso
&el símbolo & para conectar múltiples tipos - Combinación:El nuevo tipo contiene los miembros de todos los tipos.
- Mixin:Se puede utilizar para implementar la composición de funcionalidades de clases.
- never:La intersección de tipos incompatibles dará como resultado el tipo never.
Recomendación:El uso razonable de los tipos de intersección puede crear combinaciones de tipos flexibles, pero se debe tener cuidado de evitar el tipo never provocado por intersecciones de tipos innecesarias.
Otras extensiones