Interfaces

Interfaces har ingen JS-påvirkning på køretid. Der er mange muligheder i TypeScript-interfaces til at deklarere variablernes struktur.

De følgende to er ækvivalente deklarationer, den første bruger en inline-annotation, den anden bruger en grænseflade:

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

Det smukke ved eksempel B er imidlertid, at hvis nogen skriver et bibliotek, der bygger på myPoint-biblioteket for at tilføje nye medlemmer, kan de nemt tilføje til den eksisterende deklaration af myPoint:

// 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!

Det skyldes, at grænseflader i TypeScript er åbne. Det er et vigtigt princip i TypeScript, at det giver dig mulighed for at efterligne udvidelsesmulighederne i JavaScript ved hjælp af grænseflader.

Klasser kan implementere grænseflader

Hvis du vil bruge klasser, der skal følge en objektstruktur, som nogen har erklæret for dig i en interface, kan du bruge nøgleordet implements for at sikre kompatibilitet:

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

Grundlæggende vil enhver ændring i denne eksterne Point grænseflade i tilstedeværelsen af dette implements resultere i en kompileringsfejl i din kodebase, så du kan nemt holde den synkroniseret:

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

Bemærk, at implements begrænser strukturen af klasseinstanserne i.Dvs.:

var foo: Point = new MyPoint();

Og ting som foo: Point = MyPoint er ikke det samme.

Ikke alle grænseflader kan implementeres nemt

Interfaces er designet til at deklarere enhver vilkårlig skør struktur, der måtte være til stede i JavaScript.

Tænk på følgende grænseflade, hvor noget kan kaldes med new:

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

Du ville i princippet have noget som:

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

Du kan deklarere al den skøre JS derude med grænseflader og endda bruge dem sikkert fra TypeScript. Det betyder ikke, at du kan bruge TypeScript-klasser til at implementere dem.