Programación orientada a objetos con TypeScript

La programación orientada a objetos con TypeScript es una de las bases para desarrollar aplicaciones modernas con una estructura clara, reutilizable y escalable. Aunque TypeScript es un superset de JavaScript, permite implementar conceptos de la programación orientada a objetos (POO) de forma mucho más robusta, lo cual resulta clave al trabajar con frameworks como Angular o en proyectos de gran envergadura.

Este artículo es una extensión natural del anterior contenido sobre «Introducción a TypeScript«. Esta vez, nos centraremos en conceptos prácticos y avanzados de la POO, mostrando ejemplos funcionales y un proyecto ejemplo para que puedas aplicar lo aprendido. Además, profundizaremos en cómo integrar estas técnicas con buenas prácticas y herramientas modernas.

Fundamentos esenciales de la programación orientada a objetos con TypeScript

Antes de sumergirnos en ejemplos complejos, es importante repasar las bases. Los cuatro pilares fundamentales de la POO son:

• Encapsulamiento: agrupar datos y funciones que los operan en una sola unidad.
• Herencia: reutilizar funcionalidades de otras clases.
• Polimorfismo: modificar comportamientos heredados.
• Abstracción: ocultar detalles internos y exponer sólo lo necesario.

TypeScript nos permite trabajar con todos estos conceptos con una sintaxis clara y tipada. Esto mejora la mantenibilidad del código y reduce errores. Además, facilita el trabajo colaborativo en equipos de desarrollo.

Variables en programación orientada a objetos con TypeScript

En TypeScript, es importante diferenciar entre variables mutables e inmutables, y por eso se recomienda:

let edad: number = 30;
const nombre: string = "Peter Parker";

Cuando usas const con objetos o funciones, el valor referenciado no cambia, pero sus propiedades sí pueden ser modificadas:

const superheroe = { nombre: "Bruce", alias: "Batman" };
superheroe.alias = "The Dark Knight"; // permitido

Elegir entre let y const depende del comportamiento esperado del valor. Además, utilizar constantes en la medida de lo posible mejora la seguridad del código. Por tanto, se recomienda su uso para variables que no necesiten ser reasignadas.

Desestructuración y claridad en el código orientado a objetos

Una de las funcionalidades más potentes en TypeScript es la desestructuración, que permite extraer valores de objetos y arreglos de forma simple:

const { nombre, alias } = superheroe;
const [primero, segundo] = ["Iron Man", "Capitán América"];

Incluso se puede aplicar a los argumentos de funciones:

function mostrarHeroe({ nombre, alias }: { nombre: string; alias: string }) {
  console.log(`${alias} es ${nombre}`);
}

Esto ayuda a mantener funciones limpias y legibles, especialmente cuando se combinan múltiples datos de entrada. Además, mejora la legibilidad del código cuando se trabaja con múltiples propiedades.

Organización modular en la programación orientada a objetos con TypeScript

Organizar el código en módulos es esencial en la programación orientada a objetos con TypeScript. Podemos exportar e importar variables, funciones o clases:

// archivo: utilidades.ts
export const PI = 3.14;
export function saludar(nombre: string) {
  return `Hola, ${nombre}`;
}

// archivo: app.ts
import { PI, saludar } from "./utilidades";

Separar funcionalidades mejora la escalabilidad del proyecto, y además facilita el mantenimiento y pruebas. Esto es especialmente útil cuando el número de funciones crece con el tiempo.

Clases y constructores: la base de TypeScript orientado a objetos

Las clases son la piedra angular de la POO. TypeScript permite declarar clases de forma sencilla:

class Superheroe {
  constructor(public nombre: string, public poder: string) {}

  mostrarPoder() {
    console.log(`${this.nombre} tiene el poder de ${this.poder}`);
  }
}

El constructor permite inicializar valores al crear una instancia de la clase. Este enfoque garantiza que los objetos se creen de manera coherente y controlada.

Herencia en programación orientada a objetos con TypeScript

La herencia se implementa con la palabra clave extends, permitiendo que una clase derive de otra:

class Vengador extends Superheroe {
  equipo: string;

  constructor(nombre: string, poder: string, equipo: string) {
    super(nombre, poder);
    this.equipo = equipo;
  }
}

Esto ayuda a reutilizar código sin duplicarlo, y además promueve estructuras jerárquicas más organizadas. Como resultado, tu código es más eficiente.

Composición: alternativa moderna en TypeScript orientado a objetos

En muchos casos, es preferible componer objetos en lugar de usar herencia. Esto reduce el acoplamiento y aumenta la flexibilidad:

class Herramienta {
  constructor(public tipo: string) {}
}

class SuperheroeConHerramienta {
  constructor(public nombre: string, public herramienta: Herramienta) {}
}

La composición permite reutilizar funcionalidad sin crear dependencias jerárquicas. Esto, a largo plazo, facilita el mantenimiento de la base de código.

Genéricos en programación orientada a objetos con TypeScript

Los genéricos permiten trabajar con cualquier tipo manteniendo la seguridad de tipos. Son ideales para funciones reutilizables:

function identidad<T>(valor: T): T {
  return valor;
}

const heroe = identidad("Spider-Man");

O en clases:

class Caja<T> {
  contenido: T;
  constructor(valor: T) {
    this.contenido = valor;
  }
}

Utilizar genéricos potencia la escalabilidad de las herramientas reutilizables. Además, se adapta bien a estructuras de datos complejas.

Decoradores para enriquecer las clases en TypeScript

Los decoradores son funciones que se aplican a clases, métodos o propiedades. Aúdan lógica sin modificar directamente el código original:

function log(constructor: Function) {
  console.log("Clase creada:", constructor);
}

@log
class Villano {
  nombre: string = "Joker";
}

Son muy útiles en frameworks como Angular para inyectar dependencias o añadir metadatos. De este modo, se logra una programación más declarativa.

Encadenamiento opcional en programación orientada a objetos con TypeScript

Este operador permite acceder a propiedades sin lanzar errores si el valor es undefined o null:

const batman = {
  identidad: { nombre: "Bruce Wayne" }
};

console.log(batman.identidad?.nombre);

Esto evita comprobaciones innecesarias y mejora la legibilidad del código. También ayuda a reducir errores en tiempo de ejecución.

Proyecto práctico con TypeScript orientado a objetos

Vamos a desarrollar un ejemplo simple basado en superhéroes:

// archivo: herramientas.ts
export class Herramienta {
  constructor(public nombre: string) {}
}

// archivo: superheroe.ts
import { Herramienta } from "./herramientas";

export class Superheroe {
  constructor(
    public nombre: string,
    public poder: string,
    public herramienta?: Herramienta
  ) {}

  mostrar() {
    console.log(`${this.nombre} puede ${this.poder}`);
    if (this.herramienta?.nombre) {
      console.log(`Utiliza la herramienta: ${this.herramienta.nombre}`);
    }
  }
}

// archivo: app.ts
import { Superheroe } from "./superheroe";
import { Herramienta } from "./herramientas";

const martillo = new Herramienta("Mjolnir");
const thor = new Superheroe("Thor", "controlar el trueno", martillo);

thor.mostrar();

Este ejemplo muestra en acción la composición, los módulos, el encadenamiento opcional y las clases. Además, integra todo lo aprendido en un caso funcional y cercano. Por tanto, es una excelente base para proyectos reales.

Buenas prácticas en la programación orientada a objetos con TypeScript

• Prefiere const a let siempre que sea posible, ya que reduce errores de reasignación.
• Evita usar any: en su lugar, define tipos específicos.
• Divide tu código en módulos y reutiliza funciones donde tenga sentido.
• Utiliza interfaces para definir contratos claros entre clases y objetos.
• Prioriza la composición frente a la herencia siempre que el diseño lo permita.

Estas prácticas mejoran la legibilidad, el mantenimiento y la escalabilidad del proyecto. Además, fomentan una cultura de código limpio.

Conclusión

Dominar la programación orientada a objetos con TypeScript te permite construir proyectos más organizados, escalables y mantenibles. Como has podido ver, esta guía repasa desde conceptos básicos como clases o const, hasta elementos avanzados como decoradores o genéricos.

Ahora que conoces estas herramientas, puedes empezar a aplicarlas en tus propios proyectos con confianza. Y si combinas esto con otros conocimientos de TypeScript, tu código será mucho más limpio y profesional.

Además, este conocimiento te abrirá puertas para trabajar con frameworks modernos y en equipos colaborativos que exigen una base sólida en programación orientada a objetos.