Certificado de TypeScript OOP

8h 0m

Introducción a la programación orientada a objetos en TypeScript, cubriendo módulos y namespaces para un desarrollo organizado y eficiente.

Empezar curso

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.

Empezar curso

Otros cursos de programación con certificado

Supera todos los retos de TypeScript OOP y obtén estos certificados de superación para mejorar tu currículum y tu empleabilidad.

Tecnologías que aprenderás

TypeScript OOP

Al finalizar este curso obtendrás

Certificado de superación en TypeScript OOP

Certificado de superación en TypeScript OOP

Tras completar todas las lecciones y ejercicios del curso TypeScript OOP se te genera un enlace con tu certificado para que lo puedas descargar o compartir directamente en cualquier plataforma, siempre accesible.

Accede a todas certificaciones