Certificado de TypeScript OOP

TypeScript se ha consolidado como un lenguaje fundamental en el desarrollo de software moderno, extendiendo JavaScript con un sistema de tipos estático que permite crear aplicaciones robustas y mantenibles. La Programación Orientada a Objetos (OOP) en TypeScript representa uno de sus pilares más importantes, proporcionando herramientas poderosas para estructurar código de manera eficiente y escalable.

¿Qué es TypeScript OOP?

La Programación Orientada a Objetos en TypeScript combina la flexibilidad de JavaScript con un sistema de tipos robusto y características OOP avanzadas. Este paradigma permite modelar entidades del mundo real como objetos de software, encapsulando datos y comportamientos relacionados en estructuras coherentes y reutilizables.

TypeScript implementa los cuatro pilares fundamentales de la programación orientada a objetos:

• Encapsulación: Ocultar los detalles internos y exponer solo lo necesario
• Herencia: Crear nuevas clases basadas en clases existentes
• Polimorfismo: Permitir que objetos de diferentes clases respondan al mismo mensaje
• Abstracción: Simplificar sistemas complejos enfocándose en lo esencial

Fundamentos de clases y objetos

En TypeScript, las clases actúan como plantillas para crear objetos, definiendo su estructura y comportamiento. A diferencia de JavaScript tradicional, TypeScript ofrece una sintaxis clara y familiar para trabajar con clases:

class Empleado {
  nombre: string;
  edad: number;
  
  constructor(nombre: string, edad: number) {
    this.nombre = nombre;
    this.edad = edad;
  }
  
  saludar(): string {
    return `Hola, soy ${this.nombre} y tengo ${this.edad} años`;
  }
}

// Creación de un objeto (instancia)
const empleado1 = new Empleado("Ana García", 28);
console.log(empleado1.saludar()); // "Hola, soy Ana García y tengo 28 años"

Las clases en TypeScript permiten definir propiedades (datos) y métodos (funciones) que determinan el estado y comportamiento de los objetos creados a partir de ellas.

Interfaces y contratos de tipo

Las interfaces en TypeScript definen contratos que las clases deben cumplir, estableciendo una estructura clara sin implementar comportamiento. Esto facilita la creación de código modular y desacoplado:

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

class Cliente implements Persona {
  nombre: string;
  edad: number;
  numeroCliente: string;
  
  constructor(nombre: string, edad: number, numeroCliente: string) {
    this.nombre = nombre;
    this.edad = edad;
    this.numeroCliente = numeroCliente;
  }
  
  saludar(): string {
    return `Hola, soy el cliente ${this.nombre}`;
  }
}

Las interfaces actúan como contratos de tipo que garantizan que las clases implementen ciertos métodos y propiedades, mejorando la consistencia del código.

Encapsulación y modificadores de acceso

TypeScript ofrece modificadores de acceso que permiten controlar la visibilidad de propiedades y métodos, implementando el principio de encapsulación:

class CuentaBancaria {
  private saldo: number;
  protected numeroCuenta: string;
  public titular: string;
  
  constructor(titular: string, numeroCuenta: string, saldoInicial: number = 0) {
    this.titular = titular;
    this.numeroCuenta = numeroCuenta;
    this.saldo = saldoInicial;
  }
  
  public consultarSaldo(): number {
    return this.saldo;
  }
  
  public depositar(cantidad: number): void {
    if (cantidad > 0) {
      this.saldo += cantidad;
    }
  }
}

Los modificadores disponibles son:

• public: Accesible desde cualquier lugar (predeterminado)
• private: Accesible solo dentro de la clase
• protected: Accesible dentro de la clase y sus subclases

Esta capacidad de ocultar información es fundamental para crear sistemas robustos y mantenibles.

Herencia y extensión de clases

La herencia permite crear jerarquías de clases, donde las subclases heredan propiedades y métodos de sus clases padre:

class Animal {
  protected nombre: string;
  
  constructor(nombre: string) {
    this.nombre = nombre;
  }
  
  moverse(distancia: number): string {
    return `${this.nombre} se movió ${distancia} metros`;
  }
}

class Perro extends Animal {
  raza: string;
  
  constructor(nombre: string, raza: string) {
    super(nombre); // Llamada al constructor de la clase padre
    this.raza = raza;
  }
  
  ladrar(): string {
    return `${this.nombre} está ladrando`;
  }
  
  // Sobrescribir un método del padre
  moverse(distancia: number): string {
    return `${this.nombre} corrió ${distancia} metros`;
  }
}

TypeScript también soporta clases abstractas, que no pueden ser instanciadas directamente y sirven como plantillas para otras clases:

abstract class Figura {
  abstract calcularArea(): number;
  
  describir(): string {
    return `Esta figura tiene un área de ${this.calcularArea()} unidades cuadradas`;
  }
}

class Circulo extends Figura {
  radio: number;
  
  constructor(radio: number) {
    super();
    this.radio = radio;
  }
  
  calcularArea(): number {
    return Math.PI * this.radio * this.radio;
  }
}

Polimorfismo en acción

El polimorfismo permite que objetos de diferentes clases respondan al mismo mensaje de manera diferente, facilitando código flexible y extensible:

interface Reproducible {
  reproducir(): string;
}

class Video implements Reproducible {
  titulo: string;
  
  constructor(titulo: string) {
    this.titulo = titulo;
  }
  
  reproducir(): string {
    return `Reproduciendo video: ${this.titulo}`;
  }
}

class Audio implements Reproducible {
  pista: string;
  
  constructor(pista: string) {
    this.pista = pista;
  }
  
  reproducir(): string {
    return `Reproduciendo audio: ${this.pista}`;
  }
}

// Función polimórfica
function iniciarReproduccion(elemento: Reproducible): void {
  console.log(elemento.reproducir());
}

// Funciona con cualquier objeto que implemente la interfaz
iniciarReproduccion(new Video("Tutorial TypeScript"));
iniciarReproduccion(new Audio("Canción.mp3"));

El polimorfismo permite escribir código genérico que trabaja con múltiples tipos, aumentando la reutilización y reduciendo la duplicación.

Decoradores: metaprogramación en TypeScript

Los decoradores son una característica experimental que permite modificar clases y miembros de clase en tiempo de definición:

function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  
  descriptor.value = function(...args: any[]) {
    console.log(`Llamando a ${propertyKey} con argumentos: ${JSON.stringify(args)}`);
    return originalMethod.apply(this, args);
  };
  
  return descriptor;
}

class Calculadora {
  @log
  sumar(a: number, b: number): number {
    return a + b;
  }
}

const calc = new Calculadora();
calc.sumar(5, 3); // Registra: "Llamando a sumar con argumentos: [5,3]"

Los decoradores permiten implementar aspectos transversales como logging, validación o medición de rendimiento de manera declarativa.

Organización del código con módulos

Los módulos en TypeScript permiten organizar el código en unidades independientes y reutilizables:

// archivo: usuario.ts
export interface Usuario {
  id: number;
  nombre: string;
  email: string;
}

export class GestorUsuarios {
  private usuarios: Usuario[] = [];
  
  agregarUsuario(usuario: Usuario): void {
    this.usuarios.push(usuario);
  }
  
  buscarPorId(id: number): Usuario | undefined {
    return this.usuarios.find(u => u.id === id);
  }
}

// archivo: app.ts
import { Usuario, GestorUsuarios } from './usuario';

const gestor = new GestorUsuarios();
const nuevoUsuario: Usuario = { id: 1, nombre: "Carlos", email: "carlos@ejemplo.com" };
gestor.agregarUsuario(nuevoUsuario);

Los módulos facilitan la separación de responsabilidades y mejoran la mantenibilidad del código.

Namespaces para organización interna

Los namespaces proporcionan otra forma de organizar código, especialmente útil para bibliotecas grandes:

namespace Validacion {
  export interface StringValidator {
    esValido(s: string): boolean;
  }
  
  export class ValidadorEmail implements StringValidator {
    esValido(s: string): boolean {
      const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      return regex.test(s);
    }
  }
  
  export class ValidadorCodigo implements StringValidator {
    esValido(s: string): boolean {
      return s.length === 6 && !isNaN(Number(s));
    }
  }
}

// Uso
let validadorEmail = new Validacion.ValidadorEmail();
let esEmailValido = validadorEmail.esValido("test@example.com");

Los namespaces ayudan a evitar colisiones de nombres y organizan código relacionado bajo un mismo identificador.

Resolución de módulos y configuración

TypeScript ofrece diferentes estrategias de resolución de módulos que pueden configurarse en el archivo tsconfig.json:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "moduleResolution": "node",
    "baseUrl": "./src",
    "paths": {
      "@modelos/*": ["modelos/*"],
      "@servicios/*": ["servicios/*"]
    }
  }
}

Esta configuración permite importaciones personalizadas y facilita la organización de proyectos grandes:

// En lugar de importaciones relativas complejas
import { Usuario } from '@modelos/usuario';
import { AutenticacionServicio } from '@servicios/autenticacion';

Aplicaciones prácticas de TypeScript OOP

La programación orientada a objetos en TypeScript es especialmente valiosa para:

• Desarrollo de aplicaciones empresariales con modelos de dominio complejos
• Frameworks y bibliotecas que requieren extensibilidad y reutilización
• Aplicaciones frontend con arquitecturas basadas en componentes
• APIs y servicios backend con lógica de negocio estructurada
• Sistemas que evolucionan y requieren mantenimiento a largo plazo

Un ejemplo práctico es la implementación de un gestor de tareas utilizando principios OOP:

interface Tarea {
  id: number;
  titulo: string;
  completada: boolean;
  fechaCreacion: Date;
}

class GestorTareas {
  private tareas: Map<number, Tarea> = new Map();
  private ultimoId: number = 0;
  
  crearTarea(titulo: string): Tarea {
    const id = ++this.ultimoId;
    const nuevaTarea: Tarea = {
      id,
      titulo,
      completada: false,
      fechaCreacion: new Date()
    };
    
    this.tareas.set(id, nuevaTarea);
    return nuevaTarea;
  }
  
  obtenerTarea(id: number): Tarea | undefined {
    return this.tareas.get(id);
  }
  
  actualizarTarea(id: number, cambios: Partial<Tarea>): boolean {
    const tarea = this.tareas.get(id);
    if (!tarea) return false;
    
    this.tareas.set(id, { ...tarea, ...cambios });
    return true;
  }
  
  eliminarTarea(id: number): boolean {
    return this.tareas.delete(id);
  }
  
  listarTareas(): Tarea[] {
    return Array.from(this.tareas.values());
  }
}

Este ejemplo demuestra cómo TypeScript OOP facilita la creación de sistemas CRUD (Crear, Leer, Actualizar, Eliminar) con un código limpio y tipado.

Beneficios de TypeScript OOP en proyectos reales

La adopción de TypeScript con programación orientada a objetos ofrece numerosas ventajas:

• Detección temprana de errores gracias al sistema de tipos estático
• Mejor documentación implícita a través de interfaces y tipos
• Refactorización más segura con verificación de tipos en tiempo de compilación
• Mejor soporte de IDE con autocompletado y navegación de código
• Escalabilidad mejorada para equipos y proyectos grandes
• Transición más suave para desarrolladores provenientes de lenguajes como Java o C#

TypeScript OOP representa una evolución natural para proyectos JavaScript que necesitan escalar en complejidad y tamaño, proporcionando herramientas para gestionar esa complejidad de manera efectiva.