En el ámbito del desarrollo de software, comprender los paradigmas de programación es fundamental. JavaScript, un lenguaje multiparadigma, implementa la Programación Orientada a Objetos (POO) a través de un sistema basado en prototipos, lo que lo distingue de los lenguajes tradicionales basados en clases.

Paradigmas de Programación

Programación Imperativa/Procedural

Este enfoque se centra en la secuencia de acciones o pasos que el programa debe ejecutar para lograr un resultado. El código se organiza en funciones que son llamadas de manera secuencial, describiendo cómo se manipulan los datos paso a paso.

Programación Orientada a Objetos (POO)

La POO, por otro lado, estructura el software en torno a "objetos" que combinan datos (propiedades) y código (métodos) que operan sobre esos datos. Los objetos interactúan entre sí, dividiéndose el trabajo de manera colaborativa. Este paradigma promueve la modularidad, la reutilización del código y facilita el mantenimiento y la escalabilidad en proyectos complejos. Las características clave de la POO son:

• Encapsulación: Agrupar datos y los métodos que operan sobre ellos dentro de una unidad.
• Herencia: Permitir que un objeto adquiera propiedades y comportamientos de otro.
• Polimorfismo: La capacidad de diferentes objetos de responder de manera única al mismo mensaje.

Funciones Constructoras para Encapsulación

En JavaScript, las funciones constructoras son un método fundamental para implementar la encapsulación. Permiten definir una plantilla para crear objetos, donde cada instancia puede tener sus propias propiedades y métodos. Esto asegura que los datos y la lógica estén agrupados y que las instancias operen de manera independiente.

function Dispositivo(modeloInicial) {
  this.modelo = modeloInicial || 'Desconocido';

  // Método definido en cada instancia
  this.actualizarModelo = function(nuevoModelo) {
    this.modelo = nuevoModelo;
  };

  // Método definido en cada instancia
  this.obtenerModelo = function() {
    console.log(`Modelo actual: ${this.modelo}`);
  };
}

// Creación de instancias
let miTelefono = new Dispositivo('SmartphoneX');
miTelefono.actualizarModelo('Galaxy S23');
miTelefono.obtenerModelo(); // Salida: Modelo actual: Galaxy S23

let miTablet = new Dispositivo();
miTablet.obtenerModelo(); // Salida: Modelo actual: Desconocido

Aunque las funciones constructoras logran la encapsulación, si los métodos se definen directamente dentro del constructor (como actualizarModelo y obtenerModelo en el ejemplo anterior), cada nueva instancia creará una copia de esos métodos en la memoria. Esto puede generar un consumo de memoria ineficiente cuando se manejan muchas instancias.

Objetos Prototipo

Para abordar la ineficiencia de memoria y facilitar la compartición de métodos, JavaScript introduce los objetos prototipo. Cada función constructora en JavaScript tiene una propiedad especial llamada prototype, que apunta a un objeto. Este objeto prototipo es el lugar ideal para definir métodos y propiedades que deben ser compartidos por todas las instancias creadas por esa función constructora.

• La propiedad prototype es inherente a cada función constructora.
• Los métodos definidos en el prototipo no se recrean para cada instancia, ahorrando memoria.
• El contexto this dentro de los métodos del prototipo se refiere a la instancia del objeto que invocó el método.

function Vehiculo() {
  // Sin métodos definidos directamente aquí para evitar duplicación
}

// Añadiendo un método al objeto prototipo de Vehiculo
Vehiculo.prototype.arrancar = function() {
  console.log('El vehículo ha arrancado.');
};

// Instanciación
let cocheElectrico = new Vehiculo();
cocheElectrico.arrancar(); // Salida: El vehículo ha arrancado.

Cuando un método existe tanto en la instancia del objeto como en su prototipo, la versión definida en la instancia tendrá prioridad. Este comportamiento se conoce como "ocultamiento" (shadowing).

function Entidad(nombreInicial) {
  this.nombre = nombreInicial;
  // Método definido en la instancia
  this.presentarse = function() {
    console.log(`Hola, soy la instancia: ${this.nombre}`);
  };
}

// Método con el mismo nombre definido en el prototipo
Entidad.prototype.presentarse = function() {
  console.log(`Hola desde el prototipo. Mi nombre es: ${this.nombre}`);
};

let obj1 = new Entidad('Alice');
obj1.presentarse(); // Salida: Hola, soy la instancia: Alice (la versión de la instancia es prioritaria)

function ObjetoSimple() {}
ObjetoSimple.prototype.saludar = function() {
  console.log('Saludo prototípico.');
};
let obj2 = new ObjetoSimple();
obj2.saludar(); // Salida: Saludo prototípico.

Este comportamiento subraya el mecanismo de búsqueda de propiedades de JavaScript: primero se busca en la propia instancia del objeto, y si no se encuentra, se continúa la búsqueda en su cadena de prototipos.

La Propiedad constructor

Cada objeto prototipo (.prototype) tiene una propiedad constructor que, por defecto, hace referencia a la función constructora original. Esto es útil para identificar el "tipo" de un objeto. Sin embargo, si reasignamos el objeto prototype de un constructor por completo, la referencia a constructor se perderá y deberá reasignarse manualmente para mantener la consistencia.

El Enlace __proto__ / [[Prototype]]

Mientras que la propiedad prototype es exclusiva de las funciones constructoras, cada instancia de un objeto tiene un enlace interno a su objeto prototipo. Este enlace se expone comúnmente a través de la propiedad no estándar __proto__ (o formalmente [[Prototype]] en la especificación ECMAScript). Es a través de __proto__ que una instancia de objeto accede a los métodos y propiedades definidos en su prototipo.

• __proto__ (o [[Prototype]]) enlaza una instancia con el objeto prototipo de su constructor.
• La propiedad __proto__ de un objeto también tiene su propia propiedad constructor que apunta a la función constructora que creó la instancia.

Herencia Prototípica

La herencia, un pilar de la POO, se implementa en JavaScript mediante la manipulación de la cadena de prototipos. Un objeto puede "heredar" propiedades y métodos de otro, promoviendo la reutilización del código.

function SerVivo() {
  this.sistemaRespiratorio = 'pulmones';
  this.celulas = true;
}

SerVivo.prototype.respirar = function() {
  console.log('Respirando...');
};

function Mamifero() {
  this.gestacion = 'vivípara';
}

// Estableciendo la herencia: El prototipo de Mamifero hereda de SerVivo
Mamifero.prototype = new SerVivo();
Mamifero.prototype.constructor = Mamifero; // Restaurar la referencia al constructor original

Mamifero.prototype.amamantar = function() {
  console.log('Amamantando a las crías.');
};

function Ave() {
  this.plumas = true;
}

Ave.prototype = new SerVivo();
Ave.prototype.constructor = Ave;

Ave.prototype.volar = function() {
  console.log('Volando alto.');
};

let perro = new Mamifero();
console.log(perro.sistemaRespiratorio); // Salida: pulmones (heredado de SerVivo)
perro.respirar(); // Salida: Respirando... (heredado de SerVivo)
perro.amamantar(); // Salida: Amamantando a las crías. (propio de Mamifero)

let aguila = new Ave();
console.log(aguila.celulas); // Salida: true (heredado de SerVivo)
aguila.respirar(); // Salida: Respirando... (heredado de SerVivo)
aguila.volar(); // Salida: Volando alto. (propio de Ave)

La Cadena de Prototipos

La cadena de prototipos es el mecanismo fundamental de JavaScript para la búsqueda de propiedades y métodos. Cuando se acede a una propiedad en un objeto, JavaScript sigue una secuencia de búsqueda:

1. Primero, busca la propiedad directamente en el propio objeto (la instancia).
2. Si no la encuentra, busca en el objeto al que apunta su __proto__ (es decir, el prototipo del constructor).
3. Si aún no la encuentra, continúa la búsqueda en el __proto__ del prototipo anterior, y así sucesivamente.
4. Esta búsqueda continúa hasta llegar a Object.prototype (el prototipo base de todos los objetos en JavaScript), cuyo __proto__ es null, marcando el final de la cadena.

El enlace __proto__ es crucial porque define la dirección en la que JavaScript debe buscar las propiedades.

console.log(Object.prototype); // El prototipo raíz de todos los objetos
console.log(Object.prototype.__proto__); // null, el final de cualquier cadena de prototipos

function Elemento() {}
const miElemento = new Elemento();

console.log(miElemento.__proto__ === Elemento.prototype); // true: la instancia apunta al prototipo de su constructor
console.log(Elemento.prototype.__proto__ === Object.prototype); // true: el prototipo del constructor apunta a Object.prototype

// Uso del operador instanceof
console.log(miElemento instanceof Elemento); // true: miElemento fue creado por Elemento
console.log(miElemento instanceof Object);  // true: miElemento está en la cadena de prototipos de Object
console.log(miElemento instanceof Array);   // false: miElemento no está en la cadena de prototipos de Array

let listaNumeros = [1, 2, 3];
console.log(listaNumeros instanceof Array);   // true
console.log(listaNumeros instanceof Object);  // true: Array.prototype hereda de Object.prototype
console.log(Array instanceof Object);         // true: Las funciones (incluido Array) son objetos en JavaScript

El operador instanceof es una herramienta útil para verificar si la propiedad prototype de un constructor dado existe en la cadena de prototipos de un objeto. Esto permite determinar si un objeto es una instancia de un constructor específico o de cualquiera de sus ancestros en la jerarquía prototípica.