Quais problemas comuns de programação são melhor resolvidos usando protótipos e fechamentos?

Por mais que eu entenda os dois conceitos, não consigo ver como tirar proveito dos fechamentos e protótipos do JavaScript, além de usá-los para criar blocos instantâneos e / ou encapsulados em forma de classe (o que me parece mais uma solução alternativa do que um recurso para mim) )

Outros recursos de JS, como funções como valores ou avaliação lógica de não-booleanos, são muito mais fáceis de se apaixonar por ...

Quais problemas comuns de programação são mais bem resolvidos usando herança e fechamentos propotípicos?

1. Os fechamentos são o que torna as funções como valores úteis. Quando você está passando a função, você quase certamente precisa dela para levar algum contexto. Qual é exatamente o que os fechamentos fazem.

2. Protótipos são apenas uma versão mais simples da herança de classes. Em vez de ter instâncias e classes (representadas por tipos especiais de instâncias em linguagens dinâmicas de qualquer maneira), você tem apenas instâncias e o protótipo é a classe (e seu protótipo é a classe base). Então eles basicamente resolvem os mesmos problemas, apenas os protótipos são mais fáceis de implementar (é por isso que o JavaScript os escolheu), um pouco mais difíceis de usar (bem, apenas falta de açúcar sintático) e, para melhor ou pior, é mais fácil abusar.

Os fechamentos não resolvem nenhum problema de programação que não possa ser resolvido sem eles. No entanto, isso pode ser dito para qualquer recurso de idioma não necessário para a integridade de Turing, portanto, isso não significa muito.

Pense em como você deve reescrever qualquer código que use um fechamento, para não usá-lo. Você provavelmente daria à função com as propriedades extras de fechamento para que ela pudesse manter seu estado entre as chamadas. O que seria apenas copiar as variáveis ​​que já estão no escopo em propriedades com o mesmo nome na função, por isso seria o tipo de exercício de digitação irracional que faz você querer gritar na tela "por que o compilador estúpido ( intérprete, o que for) descobrir isso? " É isso o que são os fechamentos, o compilador estúpido é inteligente o suficiente para descobrir isso.

Os fechamentos são ótimos para lógica assíncrona.

É principalmente sobre organização de código para mim. É bom ter várias funções locais para dividir o que o código está fazendo.

create: function _create(post, cb) {
    // cache the object reference
    var that = this;

    function handleAll(err, data) {
        var rows = data.rows;

        var id = rows.reduce(function(memo, item) {
            var id = +item.id.split(":")[1];
            return id > memo ? id : memo;
        }, 0);
        id++;


        var obj = {
            title: post.title,
            content: post.content,
            id: id,
            // refer to the object through the closure
            _id: that.prefix + id,
            datetime: Date.now(),
            type: "post"
        }

        PostModel.insert(obj, handleInsert);
    }

    // this function doesn't use the closure at all.
    function handleInsert(err, post) {
        PostModel.get(post.id, handleGet);
    }

    // this function references cb and that from the closure
    function handleGet(err, post) {
        cb(null, that.make(post));
    }

    PostModel.all(handleAll);
}

Aqui está outro exemplo de fechamento

var cachedRead = (function() {
    // bind cache variable to the readFile function
    var cache = {};

    function readFile(name, cb) {
        // reference cache
        var file = cache[name];
        if (file) {
            return cb(null, file);
        }

        fs.readFile(name, function(err, file) {
            if (file) cache[name] = file;
            cb.apply(this, arguments);
        });
    }

    return readFile;
})();

E outro exemplo

create: function _create(uri, cb, sync) {
    // close over count
    var count = 3;

    // next only fires cb if called three times
    function next() {
        count--;
        // close over cb
        count === 0 && cb(null);
    }

    // close over cb and next
    function errorHandler(err, func) {
        err ? cb(err) : next();
    }

    // close over cb and next
    function swallowFileDoesNotExist(err, func) {
        if (err && err.message.indexOf("No such file") === -1) {
            return cb(err);
        }
        next();
    }

    this.createJavaScript(uri, swallowFileDoesNotExist, sync)

    this.createDocumentFragment(uri, errorHandler, sync);

    this.createCSS(uri, swallowFileDoesNotExist, sync);
},

A alternativa ao uso de fechamentos é transformar a variável em funções usando f.bind(null, curriedVariable).

Geralmente, porém, a lógica de programação assíncrona usa retornos de chamada e o estado de manipulação nos retornos de chamada depende de currying ou fechamento. pessoalmente eu prefiro fechamentos.

Quanto aos usos de herança prototípica, permite OO? A herança prototípica realmente precisa fazer mais do que isso para ser considerada "útil". É uma ferramenta de herança, permite herança, que é útil o suficiente.