Programación Orientada a Objetos en JavaScript

La programación orientada a objetos (POO) representa uno de los paradigmas más influyentes en el desarrollo de software moderno. En JavaScript, este paradigma ha evolucionado significativamente desde sus primeras implementaciones basadas en prototipos hasta la introducción de la sintaxis de clases en ES6, proporcionando a los desarrolladores herramientas más familiares y expresivas para estructurar código complejo.

JavaScript implementa la POO de manera única, combinando características de lenguajes basados en clases con su sistema nativo de prototipos. Esta dualidad permite múltiples aproximaciones para crear y organizar objetos, desde la herencia prototípica tradicional hasta la sintaxis moderna de clases que facilita la transición desde otros lenguajes orientados a objetos.

Fundamentos de objetos en JavaScript

Los objetos constituyen la base fundamental de JavaScript. A diferencia de los tipos primitivos, los objetos pueden contener múltiples valores relacionados y funcionalidades asociadas. Un objeto agrupa propiedades (datos) y métodos (funciones) que operan sobre esos datos, creando unidades cohesivas de funcionalidad.

const usuario = {
  nombre: "Ana García",
  edad: 28,
  email: "ana@ejemplo.com",
  
  saludar() {
    return `Hola, soy ${this.nombre}`;
  }
};

La palabra clave this representa el contexto del objeto actual, permitiendo que los métodos accedan a las propiedades del mismo objeto. Este concepto resulta fundamental para entender cómo los objetos mantienen su estado interno y exponen comportamientos específicos.

Constructores y creación de objetos

Los constructores proporcionan plantillas para crear múltiples objetos con estructura similar. JavaScript ofrece varias aproximaciones para definir constructores, desde funciones constructoras tradicionales hasta la sintaxis moderna de clases.

function Producto(nombre, precio) {
  this.nombre = nombre;
  this.precio = precio;
  this.aplicarDescuento = function(porcentaje) {
    return this.precio * (1 - porcentaje / 100);
  };
}

const laptop = new Producto("Laptop Gaming", 1200);

La sintaxis de clases introduce una forma más clara y familiar de definir constructores:

class Vehiculo {
  constructor(marca, modelo) {
    this.marca = marca;
    this.modelo = modelo;
    this.encendido = false;
  }
  
  arrancar() {
    this.encendido = true;
    return `${this.marca} ${this.modelo} arrancado`;
  }
}

Herencia y extensión de funcionalidad

La herencia permite crear nuevas clases basadas en clases existentes, reutilizando y extendiendo funcionalidad. JavaScript implementa herencia tanto a través de prototipos como mediante la palabra clave extends en clases.

class Coche extends Vehiculo {
  constructor(marca, modelo, puertas) {
    super(marca, modelo);
    this.puertas = puertas;
  }
  
  abrirPuertas() {
    return `Abriendo las ${this.puertas} puertas del ${this.modelo}`;
  }
}

La función super() invoca el constructor de la clase padre, asegurando que la inicialización se realice correctamente en toda la jerarquía de herencia.

Encapsulación y control de acceso

La encapsulación protege el estado interno de los objetos, controlando cómo se accede y modifica la información. JavaScript moderno introduce campos privados utilizando la sintaxis de almohadilla (#):

class CuentaBancaria {
  #saldo = 0;
  #numeroCuenta;
  
  constructor(numeroCuenta) {
    this.#numeroCuenta = numeroCuenta;
  }
  
  depositar(cantidad) {
    if (cantidad > 0) {
      this.#saldo += cantidad;
      return this.#saldo;
    }
  }
  
  get saldoActual() {
    return this.#saldo;
  }
}

Los getters y setters proporcionan control adicional sobre el acceso a propiedades, permitiendo validación y procesamiento de datos:

class Temperatura {
  #celsius = 0;
  
  set celsius(valor) {
    if (valor >= -273.15) {
      this.#celsius = valor;
    }
  }
  
  get fahrenheit() {
    return (this.#celsius * 9/5) + 32;
  }
}

Polimorfismo y métodos dinámicos

El polimorfismo permite que objetos de diferentes tipos respondan a la misma interfaz de manera específica. JavaScript implementa polimorfismo a través de métodos con el mismo nombre que se comportan diferentemente según el objeto:

class Forma {
  calcularArea() {
    throw new Error("Método debe ser implementado");
  }
}

class Rectangulo extends Forma {
  constructor(ancho, alto) {
    super();
    this.ancho = ancho;
    this.alto = alto;
  }
  
  calcularArea() {
    return this.ancho * this.alto;
  }
}

class Circulo extends Forma {
  constructor(radio) {
    super();
    this.radio = radio;
  }
  
  calcularArea() {
    return Math.PI * this.radio ** 2;
  }
}

Composición y agregación

La composición ofrece una alternativa a la herencia, combinando objetos para crear funcionalidad compleja. Este enfoque proporciona mayor flexibilidad y evita las limitaciones de jerarquías de herencia profundas:

class Motor {
  constructor(potencia) {
    this.potencia = potencia;
    this.funcionando = false;
  }
  
  encender() {
    this.funcionando = true;
  }
}

class Automovil {
  constructor(marca, potenciaMotor) {
    this.marca = marca;
    this.motor = new Motor(potenciaMotor);
  }
  
  arrancar() {
    this.motor.encender();
    return `${this.marca} arrancado con motor de ${this.motor.potencia}HP`;
  }
}

La programación orientada a objetos en JavaScript proporciona herramientas versátiles para organizar código complejo, desde aplicaciones web interactivas hasta sistemas backend robustos. La comprensión de estos conceptos fundamentales establece la base para desarrollar software mantenible, escalable y bien estructurado.