TypeScript: ¿Funcional o POO? ¿Qué elegir en 2024?

Dos caras de la misma moneda: Enfoque funcional y POO en TypeScript

El mundo de TypeScript es un lugar asombroso donde se mezclan las mejores prácticas de diferentes mundos. ¿Alguna vez te has preguntado por qué algunos desarrolladores escriben código usando clases y herencia, mientras que otros usan funciones puras y composición? Y lo más importante: ¿qué enfoque aportará más beneficios a tu proyecto?

En este artículo no discutiremos cuál es mejor. Analizaremos la programación funcional frente a la orientada a objetos en TypeScript con ejemplos reales. Aprenderás cuándo usar clases y cuándo usar funciones de orden superior, y cómo encontrar el punto medio en el desarrollo moderno.

¿Qué es la programación funcional en TypeScript?

La programación funcional (PF) es un paradigma donde el bloque de construcción principal son las funciones puras. Estas no modifican el estado externo y siempre devuelven el mismo resultado para los mismos datos de entrada. TypeScript soporta excelentemente la PF gracias a su tipado estricto y las capacidades de trabajar con funciones como datos.

Principios básicos de la PF en TypeScript

\n
• Inmutabilidad — los datos no se modifican, sino que se crean de nuevo
\n
• Funciones puras — sin efectos secundarios
\n
• Composición — construir comportamientos complejos a partir de funciones simples
\n
• Funciones de orden superior — funciones que reciben o devuelven otras funciones
\n

// Ejemplo de funciones puras e inmutabilidad en TypeScript\ntype User = {\n  readonly id: number;\n  readonly name: string;\n  readonly age: number;\n};\n\nconst addYear = (user: User): User => ({\n  ...user,\n  age: user.age + 1\n});\n\nconst users: User[] = [\n  { id: 1, name: 'Alice', age: 25 },\n  { id: 2, name: 'Bob', age: 30 }\n];\n\n// Sin mutaciones — creamos un nuevo array\nconst updatedUsers = users.map(addYear);\nconsole.log(users[0].age); // 25 (el original no cambió)\nconsole.log(updatedUsers[0].age); // 26\n

Observa el readonly — es una poderosa herramienta de TypeScript que ayuda a mantener la inmutabilidad a nivel de tipos.

¿Qué es la programación orientada a objetos en TypeScript?

La POO se construye alrededor de objetos que combinan datos y comportamiento. TypeScript añade a JavaScript herencia clásica, modificadores de acceso e interfaces, haciendo la POO aún más expresiva.

Principios básicos de la POO en TypeScript

\n
• Encapsulación — ocultación del estado interno mediante private y protected
\n
• Herencia — creación de jerarquías de clases
\n
• Polimorfismo — una interfaz única para diferentes implementaciones
\n
• Abstracción — trabajar a través de interfaces, no de clases concretas
\n

// Ejemplo del enfoque POO en TypeScript\nabstract class Animal {\n  constructor(protected name: string) {}\n\n  abstract makeSound(): string;\n\n  public introduce(): string {\n    return `Soy ${this.name}, y digo ${this.makeSound()}`;\n  }\n}\n\nclass Dog extends Animal {\n  constructor(name: string) {\n    super(name);\n  }\n\n  public makeSound(): string {\n    return '¡Guau!';\n  }\n}\n\nclass Cat extends Animal {\n  constructor(name: string) {\n    super(name);\n  }\n\n  public makeSound(): string {\n    return '¡Miau!';\n  }\n}\n\nconst animals: Animal[] = [new Dog('Rex'), new Cat('Whiskers')];\nanimals.forEach(a => console.log(a.introduce()));\n// Soy Rex, y digo ¡Guau!\n// Soy Whiskers, y digo ¡Miau!\n

Aquí, abstract y protected son características de TypeScript que no existen en JavaScript normal. Permiten construir una arquitectura estricta directamente a nivel de tipos.

Comparación de enfoques: ¿cuándo usar cada uno?

Analicemos algu