Interfețe

Interfețele au un impact JS zero în timpul execuției. Există o mare putere în interfețele TypeScript pentru a declara structura variabilelor.

Cele două declarații următoare sunt echivalente, prima folosește o adnotare inline, a doua folosește o interfață:

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

Cu toate acestea, frumusețea exemplului B este că, dacă cineva autorizează o bibliotecă care se bazează pe biblioteca myPoint pentru a adăuga noi membri, poate adăuga cu ușurință la declarația existentă a 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!

Acest lucru se datorează faptului că interfețele în TypeScript sunt deschise. Acesta este un principiu vital al TypeScript, care vă permite să imitați extensibilitatea JavaScript folosind interfețe.

Clasele pot implementa interfețe

Dacă doriți să utilizați clase care trebuie să urmeze o structură de obiecte pe care cineva a declarat-o pentru dvs. într-un interface puteți utiliza cuvântul cheie implements pentru a asigura compatibilitatea:

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

În principiu, în prezența acelui implements, orice modificare a acelei interfețe externe Point va duce la o eroare de compilare în codul dvs. de bază, astfel încât să puteți păstra cu ușurință sincronizarea:

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

Rețineți că implements restricționează structura instanțelor clasei i.e.:

var foo: Point = new MyPoint();

Și chestii ca foo: Point = MyPoint nu sunt același lucru.

Nu orice interfață este ușor de implementat

Interfețele sunt concepute pentru a declara orice structură arbitrară nebună care ar putea fi prezentă în JavaScript.

Considerați următoarea interfață în care ceva este apelabil cu new:

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

În esență, ați avea ceva de genul:

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

Puteți declara toate nebuniile JS existente cu interfețe și chiar le puteți folosi în siguranță din TypeScript. Asta nu înseamnă că puteți folosi clase TypeScript pentru a le implementa.

.