Qué son y cómo usar las Interfaces en TypeScript

Las Interface son una herramienta fundamental en la programación orientada a objetos, ya que nos permiten definir la estructura y el comportamiento de un objeto.

Una interfaz en TypeScript nos permite definir la estructura de un objeto, especificando los nombres y los tipos de sus propiedades y métodos.

Posteriormente, las clases pueden implementar este interface (en este caso, deben definir todas las variables y métodos que incluya el interfaz).

Declarando una interfaz

Para declarar una interfaz en Typescript, utilizamos la palabra clave interface seguida del nombre de la interfaz y las propiedades y métodos que queremos definir. Veamos un ejemplo:

interface Persona {
  nombre: string;
  edad: number;
  saludar(): void;
}

Implementando una interfaz en una clase

Una vez que hemos declarado una interfaz, podemos implementarla en una clase utilizando la palabra clave implements. Esto establece que la clase debe seguir implementar las variables y métodos declarados por la interfaz.

Veamos un ejemplo:

class Estudiante implements Persona {
  nombre: string;
  edad: number;

  constructor(nombre: string, edad: number) {
    this.nombre = nombre;
    this.edad = edad;
  }

  saludar() {
    console.log(`Hola, mi nombre es ${this.nombre} y tengo ${this.edad} años.`);
  }
}

Implementación de múltiples interfaces

Una clase puede implementar múltiples interfaces, asegurando que cumple con varios contratos.

interface Volador {
    volar(): void;
}

interface Nadador {
    nadar(): void;
}

class Pato implements Volador, Nadador {
    volar(): void {
        console.log("El pato está volando.");
    }

    nadar(): void {
        console.log("El pato está nadando.");
    }
}

const pato = new Pato();
pato.volar(); // El pato está volando.
pato.nadar(); // El pato está nadando.

Extensión de interfaces

TypeScript permite la extensión de interfaces, permitiendo crear interfaces más específicos basados en otros interfaces.

interface Animal {
    nombre: string;
}

interface Mascota extends Animal {
    vacunas: boolean;
}

const mascota: Mascota = { nombre: "Firulais", vacunas: true };
console.log(mascota); // { nombre: "Firulais", vacunas: true }

Propiedades opcionales

Las propiedades opcionales se definen añadiendo un signo de interrogación (?) después del nombre de la propiedad. Esto indica que la propiedad puede no estar presente en el objeto.

interface Libro {
    titulo: string;
    autor?: string;
}

const libro1: Libro = { titulo: "TypeScript Básico" };
const libro2: Libro = { titulo: "TypeScript Avanzado", autor: "Luis Pérez" };

Propiedades de solo lectura

Las propiedades de solo lectura se definen usando la palabra clave readonly. Esto asegura que la propiedad no puede ser modificada después de su inicialización.

interface Punto {
    readonly x: number;
    readonly y: number;
}

const punto: Punto = { x: 10, y: 20 };
// punto.x = 5; // Error: no se puede asignar a 'x' porque es una propiedad de solo lectura.