Schnittstellen

Schnittstellen haben keinen Einfluss auf die Laufzeit von JS. Es gibt eine Menge Macht in TypeScript-Schnittstellen, um die Struktur von Variablen zu deklarieren.

Die folgenden zwei sind gleichwertige Deklarationen, die erste verwendet eine Inline-Annotation, die zweite eine Schnittstelle:

// Sample A
declare var myPoint: { x: number; y: number; };
// Sample B
interface Point {
 x: number; y: number;
}
declare var myPoint: Point;

Das Schöne an Beispiel B ist jedoch, dass, wenn jemand eine Bibliothek schreibt, die auf der myPoint-Bibliothek aufbaut, um neue Mitglieder hinzuzufügen, er die bestehende Deklaration von myPoint einfach ergänzen kann:

// Lib a.d.ts
interface Point {
 x: number; y: number;
}
declare var myPoint: Point;
// Lib b.d.ts
interface Point {
 z: number;
}
// Your code
var myPoint.z; // Allowed!

Das liegt daran, dass Schnittstellen in TypeScript offen sind. Dies ist ein wichtiger Grundsatz von TypeScript, der es ermöglicht, die Erweiterbarkeit von JavaScript mit Hilfe von Schnittstellen zu imitieren.

Klassen können Schnittstellen implementieren

Wenn Sie Klassen verwenden wollen, die einer Objektstruktur folgen müssen, die jemand für Sie in einer interface deklariert hat, können Sie das Schlüsselwort implements verwenden, um Kompatibilität zu gewährleisten:

interface Point {
 x: number; y: number;
}
class MyPoint implements Point {
 x: number; y: number; // Same as Point
}

Grundsätzlich wird bei Vorhandensein dieses implements jede Änderung an dieser externen Point Schnittstelle zu einem Kompilierfehler in deiner Codebasis führen, so dass du sie einfach synchron halten kannst:

interface Point {
 x: number; y: number;
 z: number; // New member
}
class MyPoint implements Point { // ERROR : missing member `z`
 x: number; y: number;
}

Beachte, dass implements die Struktur der Klasseninstanzen einschränkt, d. h.D.h.:

var foo: Point = new MyPoint();

Und so etwas wie foo: Point = MyPoint ist nicht dasselbe.

Nicht jede Schnittstelle ist einfach zu implementieren

Schnittstellen sind dazu gedacht, jede beliebige verrückte Struktur zu deklarieren, die in JavaScript vorhanden sein könnte.

Betrachten Sie die folgende Schnittstelle, bei der etwas mit new aufrufbar ist:

interface Crazy {
 new (): {
 hello: number
 };
}

Sie hätten im Wesentlichen etwas wie:

class CrazyClass implements Crazy {
 constructor() {
 return { hello: 123 };
 }
}
// Because
const crazy = new CrazyClass(); // crazy would be {hello:123}

Sie können all das verrückte JS da draußen mit Schnittstellen deklarieren und sie sogar sicher von TypeScript aus verwenden. Das bedeutet aber nicht, dass man TypeScript-Klassen verwenden kann, um sie zu implementieren.