Types d'intersection TypeScript
Les types d'intersection combinent plusieurs types en un nouveau type qui inclut les types de tous les membres.
Cela est similaire à l'héritage multiple en programmation orientée objet, permettant à un type d'avoir les caractéristiques de plusieurs types.
Diagramme SVG : Types d'intersection
Pourquoi avons-nous besoin des types d'intersection ?
En développement, un type doit souvent avoir les caractéristiques de plusieurs types.
Par exemple, un employé est à la fois une Person et un Worker, et doit avoir les propriétés des deux.
Les types d'intersection nous permettent de combiner plusieurs types en un seul, satisfaisant ainsi cette exigence.
Explication du concept :Les types d'intersection utilisent le
&symbole pour relier plusieurs types, ce qui signifie que le nouveau type contient les membres de tous les types. Cela est similaire au concept d'héritage multiple.
Syntaxe de base
Utilisez la&symbole pour combiner plusieurs types.
Exemple
// Inclut le nom et l'âge
interface Person {
name: string;
age: number;
}
// Définir le type Worker
// Inclut le nom de l'entreprise et le salaire
interface Worker {
company: string;
salary: number;
}
// Utiliser un type d'intersection pour fusionner les deux interfaces
// Le type Employee possède toutes les propriétés de Person et de Worker
type Employee = Person & Worker;
// Créer un objet qui possède les caractéristiques des deux types
var employee: Employee = {
name: "Alice",
age: 25,
company: "Google",
salary: 100000
};
console.log("Employee: " + JSON.stringify(employee));
Sortie :
员工: {"name":"Alice","age":25,"company":"Google","salary":100000}
Explication :Un type d'intersection
A & Bsignifie que le nouveau type possède toutes les propriétés de A et B, aucune ne peut manquer.
Types d'intersection vs Héritage d'interface
Les types d'intersection peuvent remplacer l'héritage multiple d'interfaces.
Exemple
interface A {
a: string;
}
// Définir le type B
interface B {
b: nombre;
}
// Utiliser une interface pour hériter de plusieurs interfaces
// Il faut utiliser extends pour hériter de plusieurs interfaces
interface AB extends A, B {
c: booléen;
}
// Utiliser un type d'intersection (plus concis)
// Utiliser directement le symbole & pour combiner des types
type ABType = A & B & { c: boolean };
// Les deux méthodes créent un type qui contient toutes les propriétés
var obj: ABType = { a: "hello", b: 42, c: true };
console.log("Objet : " + JSON.stringify(obj));
Sortie :
对象: {"a":"hello","b":42,"c":true}
Comparaison :Les types d'intersection sont plus concis que l'héritage d'interfaces, surtout lorsque vous devez hériter de plusieurs types et ajouter des propriétés supplémentaires.
Mélange de types (patron Mixin)
L'utilisation de types d'intersection pour implémenter le patron Mixin permet de combiner dynamiquement les fonctionnalités des classes.
Exemple
// Accepte n'importe quels arguments et renvoie un objet
type Constructor = new (...args: any[]) => {};
// Mixin : ajouter la fonctionnalité d'horodatage
// Renvoie une nouvelle classe qui étend Base
function Timestamped<T extends Constructor>(Base: T) {
return class extends Base {
timestamp = Date.now();
};
}
// Mixin : ajouter la fonctionnalité de sérialisation
// Renvoie une nouvelle classe qui étend Base, incluant la méthode serialize
function Serializable<T extends Constructor>(Base: T) {
return class extends Base {
serialize() {
return JSON.stringify(this);
}
};
}
// Classe utilisateur de base
class User {
name: string;
constructor(name: string) {
this.name = name;
}
}
// Combiner les Mixins
// Créer une classe utilisateur avec fonctionnalité d'horodatage
var TimestampedUser = Timestamped(User);
// Créer une classe utilisateur avec fonctionnalité de sérialisation
var SerializableUser = Serializable(User);
// Combiner deux Mixins
var FullUser = Serializable(Timestamped(User));
// Créer une instance et tester
var user = new FullUser("Alice");
console.log("Horodatage : " + user.timestamp);
console.log("Sérialisation : " + user.serialize());
Sortie :
时间戳: 17134...
序列化: {"name":"Alice","timestamp":17134...}
Modèle de Mixin :C'est un modèle puissant qui ajoute de nouvelles fonctionnalités aux classes existantes sans les modifier.
Types d'intersection vs types d'union
Une attention particulière doit être portée à la précédence lors de la combinaison de types d'intersection et de types d'union.
Exemple
type StringOrNumber = string | number;
// Type d'intersection : intersection de types incompatibles
// string & number = never (aucun type n'est à la fois string et number)
type Both = string & number;
// Définir trois types
type A = { a: string };
type B = { b: number };
type C = { c: boolean };
// Combiner un type union et un type d'intersection
// (A | B) & C intersecte chaque branche du type union avec C
type Combined = (A | B) & C;
// Le résultat réel est : { a: string; c: boolean } | { b: number; c: boolean }
// C'est-à-dire, soit A + C, soit B + C
var obj: Combined = { a: "hello", c: true };
console.log("Combined: " + JSON.stringify(obj));
Sortie :
组合: {"a":"hello","c":true}
Important :L'intersection de types incompatibles produit le
nevertype. Par exemple,string & numberest invalide.
Types d'intersection pratiques
Les types d'intersection sont souvent utilisés pour créer des types utilitaires pour la transformation de types.
Exemple
// Parcourir toutes les propriétés de T, ajouter ? pour les rendre optionnelles
type Partial<T> = { [P in keyof T]?: T[P] };
// Type mappé : rendre toutes les propriétés obligatoires
// Parcourir toutes les propriétés de T, supprimer ? pour les rendre obligatoires
type Required<T> = { [P in keyof T]-?: T[P] };
// Type mappé : rendre toutes les propriétés readonly
// Parcourir toutes les propriétés de T, ajouter readonly
type Readonly<T> = { readonly [P in keyof T]: T[P] };
// Définir une interface de configuration
interface Config {
host: string;
port: number;
}
// Utiliser les types utilitaires
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));
Sortie :
部分: {"host":"localhost"}
必填: {"host":"localhost","port":8080}
只读: {"host":"localhost","port":8080}
Types utilitaires :La bibliothèque standard TypeScript fournit de nombreux types utilitaires basés sur les types d'intersection et les types mappés, tels que Partial, Required, Readonly, etc.
Notes
- Types incompatibles :L'intersection de types incompatibles donne never
- Précédence :Les types union ont une précédence plus élevée que les types d'intersection
- Conflits de méthodes :Si deux types ont des méthodes portant le même nom, les conflits doivent être gérés manuellement
Bonnes pratiques :Les types d'intersection conviennent pour combiner plusieurs interfaces ou types. Lorsqu'un héritage multiple est nécessaire, préférez les types d'intersection à l'héritage d'interfaces.
Résumé
Les types d'intersection sont un puissant outil de composition de types en TypeScript.
- Syntaxe :Utilisez le
&symbole pour connecter plusieurs types - Fusion :Le nouveau type contient les membres de tous les types
- Mixin:Peut être utilisé pour implémenter une composition fonctionnelle pour les classes
- never:L'intersection de types incompatibles produit le type never
Recommandation :Utiliser judicieusement les types d'intersection peut créer des compositions de types flexibles, mais veillez à éviter les types never provoqués par des intersections inutiles.
Autres extensions