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;
}

En este ejemplo, hemos declarado una interfaz llamada Persona que define tres propiedades:

• nombre de tipo string
• edad de tipo number
• saludar que es un método sin retorno (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.`);
  }
}

En este ejemplo, hemos declarado una clase llamada Estudiante que implementa la interfaz Persona.

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.

En este ejemplo, la clase Pato implementa tanto Volador como Nadador, asegurando que tiene los métodos volar y nadar.

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 }

Aquí, Mascota extiende Animal, agregando la propiedad vacunas. Cualquier objeto que implemente Mascota también debe cumplir con las propiedades de Animal.

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.

En este ejemplo, las propiedades x e y son de solo lectura y no pueden ser modificadas una vez asignadas.