TypeScript-Schnittmengentypen

Schnittmengentypen kombinieren mehrere Typen zu einem neuen Typ, der die Typen aller Mitglieder enthält.

Dies ähnelt der Mehrfachvererbung in der objektorientierten Programmierung und ermöglicht es einem Typ, die Eigenschaften mehrerer Typen zu haben.


SVG-Diagramm: Schnittmengentypen 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

Warum brauchen wir Schnittmengentypen?

In der Entwicklung muss ein Typ oft die Eigenschaften mehrerer Typen haben.

Zum Beispiel ist ein Mitarbeiter sowohl eine Person als auch ein Worker und muss die Eigenschaften von beiden haben.

Intersection-Typen ermöglichen es uns, mehrere Typen zu einem zu kombinieren und damit diese Anforderung zu erfüllen.

Konzepterklärung:Intersection-Typen verwenden das&Symbol, um mehrere Typen zu verbinden, was bedeutet, dass der neue Typ Mitglieder aller Typen enthält. Dies ähnelt dem Konzept der Mehrfachvererbung.


Grundlegende Syntax

Verwenden Sie die&Symbol, um mehrere Typen zu kombinieren.

Beispiel

// Definiere den Person-Typ
// Enthält name und age
interface Person {
    name: string;
    age: number;
}

// Definiere den Worker-Typ
// Enthält company name und salary
interface Worker {
    company: string;
    salary: number;
}

// Verwende einen Intersection-Typ, um die beiden Interfaces zusammenzuführen
// Der Typ Employee hat alle Eigenschaften von sowohl Person als auch Worker
type Employee = Person & Worker;

// Erstelle ein Objekt, das Eigenschaften beider Typen hat
var employee: Employee = {
    name: "Alice",
    age: 25,
    company: "Google",
    salary: 100000
};

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

Ausgabe:

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

Erklärung:Ein Intersection-TypA & Bbedeutet, dass der neue Typ alle Eigenschaften von sowohl A als auch B hat, keine darf fehlen.


Intersection-Typen vs. Interface-Vererbung

Intersection-Typen können die Mehrfachvererbung von Interfaces ersetzen.

Beispiel

// Definiere Typ A
interface A {
    a: string;
}

// Typ B definieren
interface B {
    b: number;
}

// Verwende ein Interface, um mehrere Interfaces zu erben
// Muss extends verwenden, um mehrere Interfaces zu erben
interface AB extends A, B {
    c: boolesch;
}

// Verwende einen Intersection-Typ (prägnanter)
// Verwende direkt das &-Symbol, um Typen zu kombinieren
type ABType = A & B & { c: boolean };

// Beide Methoden erzeugen einen Typ, der alle Eigenschaften enthält
var obj: ABType = { a: "hello", b: 42, c: true };
console.log("Object: " + JSON.stringify(obj));

Ausgabe:

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

Vergleich:Intersection-Typen sind prägnanter als Interface-Vererbung, besonders wenn Sie mehrere Typen erben und zusätzliche Eigenschaften hinzufügen müssen.


Typmischung (Mixin-Muster)

Die Verwendung von Intersection-Typen zur Implementierung des Mixin-Musters ermöglicht das dynamische Kombinieren von Klassenfunktionalität.

Beispiel

// Konstruktortyp definieren
// Akzeptiert beliebige Argumente und gibt ein Objekt zurück
type Constructor = new (...args: any[]) => {};

// Mixin: Zeitstempel-Funktionalität hinzufügen
// Gibt eine neue Klasse zurück, die Base erweitert
function Timestamped<T extends Constructor>(Base: T) {
    return class extends Base {
        timestamp = Date.now();
    };
}

// Mixin: Serialisierungsfunktionalität hinzufügen
// Gibt eine neue Klasse zurück, die Base erweitert, einschließlich der Methode serialize
function Serializable<T extends Constructor>(Base: T) {
    return class extends Base {
        serialize() {
            return JSON.stringify(this);
        }
    };
}

// Basis-Benutzerklasse
class User {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}

// Mixins kombinieren
// Eine Benutzerklasse mit Zeitstempel-Funktionalität erstellen
var TimestampedUser = Timestamped(User);
// Eine Benutzerklasse mit Serialisierungsfunktionalität erstellen
var SerializableUser = Serializable(User);
// Zwei Mixins kombinieren
var FullUser = Serializable(Timestamped(User));

// Eine Instanz erstellen und testen
var user = new FullUser("Alice");
console.log("Zeitstempel: " + user.timestamp);
console.log("Serialisierung: " + user.serialize());

Ausgabe:

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

Mixin-Muster:Dies ist ein leistungsstarkes Muster, das bestehenden Klassen neue Funktionalität hinzufügt, ohne sie zu verändern.


Intersection-Typen vs. Union-Typen

Besonderes Augenmerk muss auf die Präzedenz gelegt werden, wenn Intersection-Typen und Union-Typen kombiniert werden.

Beispiel

// Union-Typ: kann string oder number sein
type StringOrNumber = string | number;

// Intersection-Typ: Schnittmenge inkompatibler Typen
// string & number = never (kein Typ ist sowohl string als auch number)
type Both = string & number;

// Drei Typen definieren
type A = { a: string };
type B = { b: number };
type C = { c: boolean };

// Union-Typ und Intersection-Typ kombinieren
// (A | B) & C schneidet jeden Zweig des Union-Typs mit C
type Combined = (A | B) & C;

// Das tatsächliche Ergebnis ist: { a: string; c: boolean } | { b: number; c: boolean }
// Das heißt, entweder A + C oder B + C
var obj: Combined = { a: "hello", c: true };
console.log("Combined: " + JSON.stringify(obj));

Ausgabe:

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

Wichtig:Das Schneiden inkompatibler Typen ergibt denneverTyp. Zum Beispiel,string & numberist ungültig.


Praktische Schnittmengentypen

Schnittmengentypen werden oft verwendet, um Utility-Typen für die Typtransformation zu erstellen.

Beispiel

// Mapped Type: Alle Eigenschaften optional machen
// Über alle Eigenschaften von T iterieren, ? hinzufügen, um sie optional zu machen
type Partial<T> = { [P in keyof T]?: T[P] };

// Zugeordneter Typ: alle Eigenschaften erforderlich machen
// Über alle Eigenschaften von T iterieren, ? entfernen, um sie erforderlich zu machen
type Required<T> = { [P in keyof T]-?: T[P] };

// Zugeordneter Typ: alle Eigenschaften schreibgeschützt machen
// Über alle Eigenschaften von T iterieren, readonly hinzufügen
type Readonly<T> = { readonly [P in keyof T]: T[P] };

// Eine Konfigurationsschnittstelle definieren
interface Config {
    host: string;
    port: number;
}

// Utility-Typen verwenden
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));

Ausgabe:

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

Utility-Typen:Die TypeScript-Standardbibliothek bietet viele Utility-Typen auf Basis von Intersection-Typen und Mapped Types, wie z. B. Partial, Required, Readonly usw.


Hinweise

  • Inkompatible Typen:Die Schnittmenge inkompatibler Typen ergibt never
  • Vorrang:Union-Typen haben einen höheren Vorrang als Intersection-Typen
  • Methodenkonflikte:Wenn zwei Typen Methoden mit demselben Namen haben, müssen Konflikte manuell behandelt werden

Best Practices:Intersection-Typen eignen sich zum Kombinieren mehrerer Interfaces oder Typen. Wenn Mehrfachvererbung benötigt wird, sind Intersection-Typen der Interface-Vererbung vorzuziehen.


Zusammenfassung

Intersection-Typen sind ein mächtiges Werkzeug zur Typkomposition in TypeScript.

  • Syntax:Verwenden Sie das&Symbol, um mehrere Typen zu verbinden
  • Zusammenführen:Der neue Typ enthält die Mitglieder aller Typen
  • Mixin:Kann verwendet werden, um funktionale Komposition für Klassen zu implementieren
  • never:Die Schnittmenge inkompatibler Typen ergibt den never-Typ

Empfehlung:Der kluge Einsatz von Intersection-Typen kann flexible Typkompositionen schaffen, aber achten Sie darauf, never-Typen zu vermeiden, die durch unnötige Schnittmengen entstehen.


Andere Erweiterungen