Interfaces en Typescript

Una interfaz establece una especie de contrato en el que define todo lo que tiene que implementar aquello que use o implemente la interfaz.

Crear una interfaz es tan sencillo como poner la palabra reservada de interface y a continuación el nombre que le quieres dar (usualmente en PascalCase). Usar la interfaz es igual que para el resto de tipos, usando los dos puntos:

interface User {
  name: string;
  surname: string;
  age: number;
}

const user: User {
  name: "Diego",
  surname: "López",
  age: 28
}

Esto de primeras te puede resultar similar a los Type alias en Typescript, y es cierto, puedes usar las interfaces para lo mismo, pero hay ciertas Diferencias entre tipos con nombre e interfaces en Typescript, a nivel funcional e incluso conceptual.

Extensión de interfaces

Una cosa que se puede hacer con las interfaces es extenderlas, es decir, que una interfaz amplíe a otra, esto se hace usando la keyword de extends, ejemplo:

interface Vehicle {
  brand: string;
  year: number;
}

interface LandVehicle extends Vehicle {
  wheels: number;
}

interface AirVehicle extends Vehicle {
  wings: number;
  altitude: number;
}

En este ejemplo cada uno de los tipos de vehículo heredará todas las propiedades del vehículo estándar.

Implementación de interfaces en clases

Se pueden usar las interfaces para definir la implementación que va a tener una clase en el Tipado de clases en Typescript. Para ello tienes que usar la keyword implements seguida del nombre de tu interfaz.

Y es que una cosa que no he mencionado es que dentro de las interfaces también puedes definir métodos que tienen que implementar el que use dicha interfaz.

interface Vehicle {
  name: string;
  drive(): void;
  refuel(liters: number): void;
}

class Car implements Vehicle {
  name: string;
  
  constructor(name: string) {
    this.name = name;
  }
	
  drive(): void {
    console.log("Driving!");
  }
  refuel(liters: number): void {
    console.log("Filling the tank!");
  }
  openDoors(): void {
    console.log("Opening the doors!");
  }
}

Ojo al detalle de que el método openDoors no está definido en la interfaz que implementa, y es que la interfaz define el mínimo de elementos que tiene que cumplir el que implementa dicha interfaz.