Tutorial JavaScript: Polimorfismo

El polimorfismo es un concepto clave en la programación orientada a objetos que permite que diferentes objetos puedan ser tratados como objetos de una superclase común. JavaScript es un lenguaje de programación basado en prototipos que admite la herencia y el polimorfismo a través de funciones constructoras y objetos prototipo.

En JavaScript, el polimorfismo se refiere a la capacidad de una función o método para operar en diferentes objetos independientemente de su tipo, siempre que esos objetos compartan una propiedad o método común. Esto es posible gracias a que JavaScript es un lenguaje de tipado dinámico, lo que permite que los objetos tengan propiedades y métodos asignados en tiempo de ejecución.

Uso básico de polimorfismo

A continuación se muestra un ejemplo de implementación de polimorfismo en JavaScript, en el que se definen dos subclases Perro y Gato que heredan de la superclase Animal, de forma que cada una tenga su propia implementación de un método hablar().

// Función constructora para la clase Animal
function Animal(nombre) {
  this.nombre = nombre;
}

// Método común para todos los animales
Animal.prototype.hablar = function() {
  console.log(`${this.nombre} hace un ruido.`);
};

// Función constructora para la clase Perro que hereda de Animal
function Perro(nombre) {
  Animal.call(this, nombre);
}

// Establecer la herencia del prototipo de Animal en Perro
Perro.prototype = Object.create(Animal.prototype);
Perro.prototype.constructor = Perro;

// Sobreescribir el método hablar para la clase Perro
Perro.prototype.hablar = function() {
  console.log(`${this.nombre} ladra.`);
};

// Función constructora para la clase Gato que hereda de Animal
function Gato(nombre) {
  Animal.call(this, nombre);
}

// Establecer la herencia del prototipo de Animal en Gato
Gato.prototype = Object.create(Animal.prototype);
Gato.prototype.constructor = Gato;

// Sobreescribir el método hablar para la clase Gato
Gato.prototype.hablar = function() {
  console.log(`${this.nombre} maúlla.`);
};

// Crear instancias de Perro y Gato
const perro = new Perro('Max');
const gato = new Gato('Felix');

// Uso de polimorfismo al llamar al método hablar en ambos objetos
perro.hablar(); // Max ladra.
gato.hablar(); // Felix maúlla.

// Función que hace uso del polimorfismo al aceptar cualquier objeto que tenga un método hablar
function hazHablar(animal) {
  animal.hablar();
}

hazHablar(perro); // Max ladra.
hazHablar(gato); // Felix maúlla.

En el ejemplo anterior, se definen dos subclases Perro y Gato que heredan de la superclase Animal. Ambas subclases sobreescriben el método hablar del prototipo de Animal. Cuando se crea una instancia de Perro o Gato y se llama al método hablar, se ejecuta la implementación específica de la subclase.

La función hazHablar acepta cualquier objeto que tenga un método hablar y demuestra el polimorfismo en acción. No importa si se pasa un objeto de tipo Perro, Gato o cualquier otro objeto con un método hablar, la función hazHablar siempre llamará al método hablar del objeto proporcionado.

De esta manera, el polimorfismo en JavaScript permite tratar diferentes objetos como si fueran de la misma superclase y ejecutar métodos compartidos sin necesidad de conocer los detalles específicos de cada objeto. Esto proporciona abstracción y flexibilidad en el diseño y la implementación de software.

Polimorfismo ad hoc

El polimorfismo en JavaScript no solo se limita a la herencia y la implementación de métodos en clases y subclases. También se puede lograr el polimorfismo a través del uso de objetos y funciones que aprovechan la naturaleza dinámica y flexible del lenguaje. Un ejemplo comúnmente utilizado en JavaScript es el polimorfismo ad hoc, que se refiere a la capacidad de una función para trabajar con diferentes tipos de datos sin necesidad de crear múltiples funciones similares.

Uno de los enfoques para implementar el polimorfismo ad hoc en JavaScript es mediante la verificación de propiedades y tipos en tiempo de ejecución dentro de una función. Por ejemplo:

function imprimir(objeto) {
  if (typeof objeto.toString === 'function') {
    console.log(objeto.toString());
  } else {
    console.log('El objeto no tiene un método toString.');
  }
}

La función imprimir muestra cómo aprovechar la introspección y la capacidad de JavaScript para verificar las propiedades y funciones de un objeto en tiempo de ejecución. Como resultado, puede aceptar cualquier objeto que tenga un método toString sin importar su tipo exacto.

Otro enfoque para el polimorfismo en JavaScript se basa en la composición de objetos, donde un objeto obtiene su comportamiento y características únicas a través de la agregación de componentes en lugar de extender una superclase.

const conSaludar = (objeto, nombre) => ({
  ...objeto,
  saludar: () => console.log(`Hola, mi nombre es ${nombre}`)
});

const conDespedir = (objeto) => ({
  ...objeto,
  despedir: () => console.log(`Adiós`)
});

const objetoCompuesto = conSaludar(conDespedir({}), 'Juan');
objetoCompuesto.saludar(); // Hola, mi nombre es Juan
objetoCompuesto.despedir(); // Adiós

En este ejemplo, conSaludar y conDespedir son funciones que agregan nuevos comportamientos a un objeto. Al combinar estos dos componentes, podemos crear un objeto que tenga ambos comportamientos sin recurrir a la herencia típica.

En resumen, el polimorfismo en JavaScript no solo está relacionado con el uso de superclases y herencia, sino también con las capacidades dinámicas y flexibles que ofrece el lenguaje. Esto incluye el polimorfismo ad hoc y la composición de objetos, que permite diseñar soluciones flexibles y escalables que se adapten mejor a la evolución de los requerimientos del software.