Interfaces

Las interfaces tienen cero impacto en JS en tiempo de ejecución. Hay mucho poder en las interfaces de TypeScript para declarar la estructura de las variables.

Las dos siguientes son declaraciones equivalentes, la primera utiliza una anotación inline, la segunda utiliza una interfaz:

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

Sin embargo, la belleza de la muestra B es que si alguien crea una biblioteca que se basa en la biblioteca myPoint para añadir nuevos miembros, puede añadir fácilmente a la declaración 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!

Esto se debe a que las interfaces en TypeScript son abiertas. Este es un principio vital de TypeScript que le permite imitar la extensibilidad de JavaScript usando interfaces.

Las clases pueden implementar interfaces

Si quieres usar clases que deben seguir una estructura de objetos que alguien declaró para ti en un interface puedes usar la palabra clave implements para asegurar la compatibilidad:

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

Básicamente en presencia de ese implements, cualquier cambio en esa interfaz externa Point resultará en un error de compilación en tu base de código para que puedas mantenerlo fácilmente sincronizado:

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 la estructura de las instancias de la clase i.e.:

var foo: Point = new MyPoint();

Y cosas como foo: Point = MyPoint no es lo mismo.

No toda interfaz es implementable fácilmente

Las interfaces están diseñadas para declarar cualquier estructura arbitrariamente loca que pueda estar presente en JavaScript.

Considera la siguiente interfaz en la que algo es invocable con new:

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

Esencialmente tendrías algo como:

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

Puedes declarar todas las locuras de JS que hay con interfaces e incluso usarlas con seguridad desde TypeScript. No significa que puedas usar clases de TypeScript para implementarlas.