Organizar JavaScript basado en prototipos manteniendo la referencia y la herencia de objetos

Dilema: reorganizar el código para mejorar la estructura

La herencia de prototipos es un poderoso paradigma de JavaScript, pero gestionar aplicaciones de gran tamaño puede resultar un desafío. Considere una clase de carrusel con numerosas funciones:

Carousel.prototype.next = function () {...}
Carousel.prototype.prev = function () {..}
Carousel.prototype.bindControls = function () {..}

La refactorización para una mejor organización del código puede implicar agrupar funciones en subobjetos:

Carousel.prototype.controls = {
   next: function () { ... } , 
   prev: function() { ... },
   bindControls: function () { .. }
}

Sin embargo, este cambio presenta un problema: la palabra clave "this" dentro de estas funciones ya no hace referencia a la instancia del carrusel.

Superando el problema de "this"

Mantener El contexto "este" es crucial, especialmente en escenarios donde las clases heredan de las clases principales. Las funciones anuladas en clases heredadas deben preservar el comportamiento adecuado de "este".

Soluciones

Ajuste de subobjetos

Un enfoque es definir controles como una clase separada y almacenar una referencia a la instancia del carrusel:

var Controls = function (controllable_object) {
    this.ref = controllable_object;
};
Controls.prototype.next = function () {
    this.ref.foo();
}
// ..

Si bien esta solución soluciona el problema "este", evita la anulación de la implementación de controles.

Inyección de dependencia

Un enfoque más flexible implica la inyección de dependencia :

var Controls = function (controllable_object) {
    this.ref = controllable_object;
};
Controls.prototype.next = function () {
    this.ref.foo();
}
// ..

var Carousel = function () {
        this.controllers = [];
    };
Carousel.prototype.addController = function (controller) {
        this.controllers.push(controller);
    };
// ..

En este escenario, la clase carrusel puede agregar múltiples controladores, acomodando múltiples conjuntos de funcionalidades y permitiendo anulaciones fáciles.