Interfészek

Az interfészeknek nincs futásidejű JS-hatásuk. A TypeScript interfészekben rengeteg lehetőség van a változók szerkezetének deklarálására.

A következő két deklaráció egyenértékű, az első egy inline annotációt használ, a második egy interfészt:

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

A B minta szépsége azonban abban rejlik, hogy ha valaki olyan könyvtárat ír, amely a myPoint könyvtárra épül, hogy új tagokat adjon hozzá, akkor könnyen kiegészítheti a myPoint meglévő deklarációját:

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

Ez azért van, mert a TypeScriptben az interfészek nyílt végűek. Ez a TypeScript egyik fontos alapelve, hogy lehetővé teszi a JavaScript bővíthetőségének utánzását az interfészek segítségével.

Az osztályok megvalósíthatják az interfészeket

Ha olyan osztályokat szeretne használni, amelyeknek egy olyan objektumstruktúrát kell követniük, amelyet valaki egy interface-ben deklarált az Ön számára, akkor a kompatibilitás biztosítása érdekében használhatja a implements kulcsszót:

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

Lényegében ennek a implements-nek a jelenlétében a külső Point interfész bármilyen változása fordítási hibát fog eredményezni a kódbázisodban, így könnyen szinkronban tarthatod:

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

Megjegyezzük, hogy a implements korlátozza az osztálypéldányok szerkezetét i.Pl.:

var foo: Point = new MyPoint();

Az olyan dolgok, mint a foo: Point = MyPoint nem ugyanaz a dolog.

Nem minden interfész implementálható könnyen

Az interfészek arra szolgálnak, hogy bármilyen tetszőlegesen őrült struktúrát deklaráljanak, ami a JavaScriptben előfordulhat.

Gondoljunk csak a következő interfészre, ahol valami hívható a new-vel:

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

Lényegében valami ilyesmi lenne:

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

Az összes létező őrült JS-t deklarálhatjuk interfészekkel, és még biztonságosan használhatjuk is őket TypeScriptből. Ez nem jelenti azt, hogy TypeScript osztályokat használhatsz az implementálásukhoz.