JavaScript implementa la herencia y la reutilización de código a través de un modelo basado en prototipos. En este lenguaje, cada objeto mantiene una referencia interna oculta hacia otro objeto, denominado su prototipo. Esta referencia actúa como un puente que permite a los objetos acceder a propiedades y métodos compartidos, estableciendo así una cadena de delegación.

Resolución de Propiedades y el Flujo de Búsqueda

Cuando el motor de JavaScript intenta aceder a una propiedad o ejecutar un método en un objeto específico, sigue un algoritmo de búsqueda estricto. Inicialmente, verifica si la propiedad existe directamente en el objeto (propiedad propia). Si la búsqueda resulta infructuosa, el intérprete sigue el enlace interno hacia el prototipo del objeto y repite la comprobación. Este proceso continúa recursivamente a través de la cadena hasta que se localiza el miembro o hasta que se alcanza el final de la cadena, que es Object.prototype (cuyo prototipo interno es null).

Implementación Básica de un Protoitpo

Consideremos la creación de una estructura para representar vehículos. Podemos definir un constructor y asignar métodos directamente a su prototipo para que sean compartidos:

function Vehicle(brand) {
    this.brand = brand;
}

Vehicle.prototype.startEngine = function() {
    return `Engine of ${this.brand} started.`;
};

const myCar = new Vehicle("Toyota");

En este escenario, cuando se ejecuta myCar.startEngine(), el motor nota que myCar no posee el método startEngine en su propio contexto. Inmediatamente, delega la búsqueda a Vehicle.prototype, donde la función es encontrada y ejecutada.

Establecimiento de Herencia Prototípica

Para crear una jerarquía donde un objeto herede el comportamiento de otro, es necesario manipular la cadena de prototipos. Supongamos que necesitamos un constructor ElectricCar que herede de Vehicle:

function ElectricCar(brand, batteryCapacity) {
    Vehicle.call(this, brand);
    this.batteryCapacity = batteryCapacity;
}

// Establecer la cadena de herencia
ElectricCar.prototype = Object.create(Vehicle.prototype);
ElectricCar.prototype.constructor = ElectricCar;

// Añadir métodos específicos
ElectricCar.prototype.chargeBattery = function() {
    return "Battery is charging...";
};

const myTesla = new ElectricCar("Tesla", 100);

Al utilizar Object.create, el prototipo de ElectricCar apunta a Vehicle.prototype. Si invocamos myTesla.startEngine(), la búsqueda recorrerá: myTesla (no encontrado) -> ElectricCar.prototype (no encontrado) -> Vehicle.prototype (encontrado). Esto demuestra cómo la delegación prototípica permite la extensión de funcionalidades sin duplicar código.

Ventajas Arquitectónicas

• Eficiencia en el Consumo de Memoria: Al definir funciones en el prototipo en lugar de dentro del constructor, todas las instancias comparten la misma referencia de función. Esto evita la creación de múltiples copias del mismo método en la memoria.
• Flexibilidad Dinámica: La naturaleza de la cadena permite inyectar o modificar métodos en tiempo de ejecución. Cualquier alteración realizada en un prototipo se refleja instantáneamnete en todos los objetos que dependan de él, facilitando la extensión de bibliotecas o la aplicación de polyfills.