Interfaces

Interfaces com impacto JS de tempo de execução zero. Há muito poder nas interfaces TypeScript para declarar a estrutura das variáveis.

As duas seguintes são declarações equivalentes, a primeira usa uma anotação em linha, a segunda usa uma interface:

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

No entanto, a beleza da Amostra B é que se alguém criar uma biblioteca que se baseie na biblioteca myPoint para adicionar novos membros, pode facilmente adicionar à declaração existente de 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!

Isto é porque as interfaces em TypeScript são abertas. Este é um princípio vital do TypeScript que lhe permite imitar a extensibilidade do JavaScript usando interfaces.

Classes podem implementar interfaces

Se você quiser usar classes que devem seguir uma estrutura de objetos que alguém declarou para você em um interface você pode usar a palavra-chave implements para garantir a compatibilidade:

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

Basicamente na presença daquela implements, qualquer alteração naquela interface externa Point resultará em um erro de compilação na sua base de código para que você possa facilmente mantê-la em sincronia:

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

Nota que implements restringe a estrutura das instâncias da classe i.e.:

var foo: Point = new MyPoint();

E coisas como foo: Point = MyPoint não é a mesma coisa.

Nem todas as interfaces são facilmente implementáveis

Interfaces são desenhadas para declarar qualquer estrutura arbitrariamente louca que possa estar presente no JavaScript.

Considerar a seguinte interface onde algo é chamável com new:

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

Você teria essencialmente algo como:

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

Você pode declarar todas as loucuras do JS lá fora com interfaces e até mesmo usá-las com segurança a partir do TypeScript. Não significa que você pode usar classes TypeScript para implementá-las.