Apa masalah pemrograman umum yang paling baik diselesaikan dengan menggunakan prototipe dan penutupan?

Sejauh saya memahami kedua konsep, saya tidak bisa melihat bagaimana saya bisa mengambil keuntungan dari penutupan JavaScript dan prototipe selain menggunakannya untuk membuat blok kelas-suka seperti / dan enkapsulasi (yang tampaknya lebih merupakan solusi daripada aset bagi saya )

Fitur JS lainnya seperti fungsi-nilai-atau evaluasi logis dari non-boolean jauh lebih mudah untuk jatuh cinta dengan ...

Apa masalah pemrograman umum yang paling baik diselesaikan dengan menggunakan pewarisan dan penutupan propotypal?

1. Penutupan inilah yang menjadikan fungsi sebagai nilai yang berguna. Ketika Anda melewati fungsi, Anda hampir pasti membutuhkannya untuk membawa beberapa konteks. Itulah tepatnya yang dilakukan penutupan.

2. Prototipe hanyalah versi sederhana dari pewarisan kelas. Alih-alih memiliki instance dan kelas (diwakili oleh jenis instance khusus dalam bahasa dinamis), Anda hanya memiliki instance dan prototipe adalah kelas (dan prototipe itu adalah kelas dasar). Jadi mereka pada dasarnya memecahkan masalah yang sama, hanya prototipe yang lebih mudah untuk diimplementasikan (itu sebabnya JavaScript memilih mereka), agak sulit untuk digunakan (yah, hanya kekurangan gula sintaksis) dan untuk lebih baik atau lebih buruk lebih mudah untuk penyalahgunaan.

Penutupan tidak memecahkan masalah pemrograman yang tidak dapat diselesaikan tanpa mereka. Namun, ini dapat dikatakan untuk fitur bahasa apa pun yang tidak diperlukan untuk kelengkapan Turing, sehingga tidak banyak berarti.

Pikirkan tentang bagaimana Anda harus menulis ulang kode apa pun yang menggunakan penutupan, untuk tidak menggunakan penutupan. Anda mungkin akan memberikan fungsi dengan properti tambahan penutupan sehingga bisa menahan keadaan di antara panggilan. Yang hanya akan menyalin variabel yang sudah dalam lingkup ke properti dengan nama yang sama pada fungsi, jadi itu akan menjadi jenis latihan mengetik tanpa berpikir yang membuat Anda ingin berteriak di layar "mengapa kompiler bodoh ( penerjemah, terserahlah). Yang ini apa penutupan yang, compiler bodoh adalah cukup pintar untuk angka itu.

Penutupan bagus untuk logika asinkron.

Ini terutama tentang pengorganisasian kode untuk saya. Memiliki banyak fungsi lokal untuk membagi apa yang dikerjakan kode itu bagus.

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

Berikut ini contoh lain dari penutupan

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

Dan contoh lainnya

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);
},

Alternatif untuk menggunakan closure adalah mengubah variabel menjadi fungsi menggunakan f.bind(null, curriedVariable).

Namun secara umum, logika pemrograman asinkron menggunakan panggilan balik dan memanipulasi keadaan dalam panggilan balik bergantung pada currying atau penutupan. secara pribadi saya lebih suka penutupan.

Adapun penggunaan pewarisan prototypical, memungkinkan OO? Apakah warisan prototipe benar-benar perlu melakukan lebih dari itu agar dianggap "berguna". Ini alat warisan, memungkinkan warisan, itu cukup berguna.