Eu tenho refatorado o código JavaScript de outra pessoa.

ANTES:

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`...*/

DEPOIS DE:

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 mim, o primeiro exemplo parece difícil de ler, especialmente em um contexto maior. Adicionando métodos comoreset assim, usando oprototype propriedade, parece muito menos controlada, pois pode acontecer em qualquer lugar do script. Meu código refatorado (o segundo exemplo acima) parece muito mais agradável para mim e, portanto, é mais fácil de ler porque é autocontido. Eu ganhei um pouco de privacidade com as declarações de variáveis, mas perdi as possibilidades da cadeia de protótipos.

...

QUESTÕES:

Em primeiro lugar, estou interessado em saber o que mais eu perdi por renunciarprototype, ou se houver implicações maiores para a perda da cadeia de protótipos.Este artigo tem 6 anos, mas afirma que usando oprototype a propriedade é muito mais eficiente em grande escala do que os padrões de fechamento.

Ambos os exemplos acima ainda seriam instanciados por umnew operador; ambos são construtores "clássicos". Eventualmente eu gostaria de me afastar disso em um modelo onde todas as propriedades e funções são declaradas comovare eu tenho um método que eu exponho capaz de retornar um objeto abrindo todas as propriedades e métodos que eu preciso,que têm privilégios (em virtude de fechamento) para aqueles que são privados. Algo assim:

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();

Existem algumas respostas no StackOverflow abordando a questão 'protótipo vs. fechamento' (Aqui eAqui, por exemplo). Mas, como acontece com oprototype propriedade, estou interessado em que um movimento em direção a isso e longe donew operador significa para a eficiência do meu código e para qualquer perda de possibilidade (por ex.instanceof está perdido). Se eu não vou estar usando herança prototypal de qualquer maneira, eu realmente perco qualquer coisa em renunciar anew operador?

Uma pergunta mais solta se for permitido, dado que estou pedindo detalhes acima: seprototype enew são realmente o caminho mais eficiente a seguir, com mais vantagens (o que você acha que elas possam ser) do que o fechamento, existem diretrizes ou padrões de design para escrevê-los de maneira mais clara?

...

ATUALIZAR:

Observe queexpose retorna um novo objeto a cada vez, então é aí que a instanciação acontece. Pelo que entendi, onde esse objeto se refere a métodos declarados noSomeObj fechamento, eles são os mesmos métodos em todos os objetos (a menos que sejam sobrescritos). No caso doflag variável (que agora corrijo), isso pode ser herdado do argumento deexpose, tem um valor padrão ou volta novamente a um método ou propriedade pré-existente encapsulado. Então, há instâncias de objetos sendo produzidos e há alguma herança (mais polimorfismo?) Acontecendo aqui.

Então, para repetir a pergunta 2: se eu não vou usar herança prototypal, de qualquer forma, eu realmente perco qualquer coisa em renunciar anew operador?

Muito obrigado pelas respostas até agora, que ajudaram a esclarecer minha dúvida.