Lección 83 — Interfaces

🧠 Concepto

Las interfaces son una de las formas más poderosas de definir la forma (shape) de un objeto en TypeScript. Definen un contrato que las estructuras de datos deben cumplir.

Sintaxis básica

interface Persona {
  nombre: string;
  edad: number;
}

let ana: Persona = {
  nombre: 'Ana',
  edad: 30
};

Propiedades requeridas y opcionales

Por defecto, todas las propiedades son requeridas. Las opcionales se marcan con ?:

interface Configuracion {
  url: string;          // requerida
  puerto?: number;      // opcional
  debug?: boolean;      // opcional
}

Métodos en interfaces

Puedes definir métodos sin implementación:

interface Animal {
  nombre: string;
  sonido(): string;       // método que retorna string
  mover(distancia: number): void;
}

class Perro implements Animal {
  nombre: string;
  constructor(nombre: string) { this.nombre = nombre; }
  sonido(): string { return 'Guau'; }
  mover(distancia: number): void {
    console.log(`Corrió ${distancia} metros`);
  }
}

Interface para funciones

También puedes describir funciones con interfaces:

interface Comparador {
  (a: number, b: number): number;
}

const ordenarAsc: Comparador = (a, b) => a - b;
const ordenarDesc: Comparador = (a, b) => b - a;

Duck typing / Structural typing

TypeScript usa tipado estructural (duck typing): si un objeto tiene la forma correcta, es compatible con la interfaz, sin importar su nombre o declaración explícita.

interface Vehiculo {
  ruedas: number;
  mover(): void;
}

// Este objeto cumple la interfaz sin implementarla explícitamente
const bicicleta = {
  ruedas: 2,
  mover: () => console.log('Pedaleando')
};

function usarVehiculo(v: Vehiculo): void {
  v.mover();
}

usarVehiculo(bicicleta); // ✅ funciona por la forma, no por la herencia

💻 Ejemplo

interface Usuario {
  id: number;
  nombre: string;
  email: string;
  activo?: boolean;
  obtenerNombreCompleto(): string;
}

const usuario: Usuario = {
  id: 1,
  nombre: 'Ana García',
  email: 'ana@mail.com',
  activo: true,
  obtenerNombreCompleto() {
    return this.nombre;
  }
};

function mostrarUsuario(u: Usuario): void {
  console.log(`#${u.id}: ${u.obtenerNombreCompleto()} (${u.email})`);
  if (u.activo) console.log('✅ Activo');
}

mostrarUsuario(usuario);

📝 Ejercicio

Define una interfaz Libro con: titulo (string), autor (string), año (number), genero (string opcional), y un método resumen(): string que retorne un texto con el título y autor.

Crea al menos dos objetos que implementen esta interfaz (uno explícitamente con : Libro y otro solo por su forma) y escribe una función que los procese.

⚠️ Nota

Al contrario que en otros lenguajes (Java, C#), en TypeScript no necesitas usar implements para que un objeto cumpla una interfaz. Si tiene la forma correcta, TS lo acepta automáticamente.

🎯 Tip

Usa interfaces para definir contratos públicos de tu aplicación: formas de objetos que vienen de APIs, props de componentes, modelos de datos. Son ideales para documentar la estructura esperada.