He estado re-factorizando el código de JavaScript de otra persona.

ANTES DE:

function SomeObj(flag) {
    var _private = true;
    this.flag = (flag) ? true : false;
    this.version="1.1 (prototype)";
    if (!this._someProperty) this._init();
            // leading underscore hints at what should be a 'private' to me
    this.reset(); // assumes reset has been added...
}

SomeObj.prototype.reset = function() {
    /* perform some actions */
}

/* UPDATE */
SomeObj.prototype.getPrivate = function() {
    return _private; // will return undefined
}

/* ...several other functions appended via `prototype`...*/

DESPUÉS:

var SomeObj = function (flag) {
    var _private = true;
    this.flag = (flag) ? true : false;
    this.version = "2.0 (constructor)";

    this.reset = function () {
       /* perform some actions */
    };

    /* UPDATE */
    this.getPrivate = function() {
        return _private; // will return true
    }

    /* other functions and function calls here */
}

Para mí, el primer ejemplo parece difícil de leer, especialmente en un contexto más amplio. Añadiendo métodos comoreset de esta manera, usando elprototype propiedad, parece mucho menos controlada, ya que presumiblemente puede suceder en cualquier parte del script. Mi código refactorizado (el segundo ejemplo anterior) me parece mucho mejor y, por lo tanto, es más fácil de leer porque es autónomo. He ganado algo de privacidad con las declaraciones variables, pero he perdido las posibilidades de la cadena de prototipos.

...

PREGUNTAS:

En primer lugar, me interesa saber qué más he perdido por lo anterior.prototype, o si hay mayores implicaciones para la pérdida de la cadena del prototipo.Este artículo Tiene 6 años pero afirma que al usar elprototype La propiedad es mucho más eficiente a gran escala que los patrones de cierre.

Los dos ejemplos anteriores aún serían ejemplificados por unnew operador; ambos son constructores "clásicos". Finalmente, incluso me gustaría alejarme de esto a un modelo donde todas las propiedades y funciones se declaran comovars y tengo un método que expongo que es capaz de devolver un objeto abriendo todas las propiedades y métodos que necesito,que tienen privilegios (en virtud del cierre) a aquellos que son privados. Algo como esto:

var SomeObj = (function () {

    /* all the stuff mentioned above, declared as 'private' `var`s */

    /* UPDATE */
    var getPrivate = function () {
        return private;
    }

    var expose = function (flag) {
         // just returns `flag` for now
         // but could expose other properties
         return {
             flag: flag || false, // flag from argument, or default value
             getPrivate: getPrivate
         } 
    };

    return {
        expose: expose
    }
})(); // IIFE

// instead of having to write `var whatever = new SomeObj(true);` use...
var whatever = SomeObj.expose();

Hay algunas respuestas en StackOverflow que abordan la pregunta 'prototipo frente a cierre' (aquí yaquí, por ejemplo). Pero, como con elprototype propiedad, estoy interesado en lo que un movimiento hacia esto y lejos de lanew operador significa la eficiencia de mi código y cualquier pérdida de posibilidad (por ejemplo,instanceof está perdido). De todos modos, si no voy a utilizar la herencia prototípica, ¿pierdo algo en el proceso anterior?new ¿operador?

Una pregunta más flexible si se me permite, dado que estoy pidiendo detalles arriba: siprototype ynew realmente son la forma más eficiente de ir, con más ventajas (sean las que creas que son) que el cierre, ¿existen pautas o patrones de diseño para escribirlas de manera ordenada?

...

ACTUALIZAR:

Tenga en cuenta queexpose devuelve un objeto nuevo cada vez, por lo que aquí es donde ocurre la creación de instancias. Como entiendo esto, cuando ese objeto se refiere a métodos declarados en elSomeObj de cierre, son los mismos métodos en todos los objetos (a menos que se sobrescriban). En el caso de laflag variable (que ahora he corregido), esto puede heredarse del argumento deexpose, tenga un valor predeterminado, o vuelva a consultar un método o una propiedad encapsulados preexistentes. Entonces, hay casos en que se producen objetos y hay alguna herencia (¿más polimorfismo?) Que está ocurriendo aquí.

Entonces, para repetir la pregunta 2: si no voy a utilizar la herencia prototípica de todos modos, ¿realmente pierdo algo por lo anterior?new ¿operador?

Muchas gracias por las respuestas hasta ahora, que han ayudado a aclarar mi pregunta.