Welche häufigen Programmierprobleme lassen sich am besten mit Prototypen und Verschlüssen lösen?

So gut ich beide Konzepte verstehe, kann ich nicht erkennen, wie ich die Verschlüsse und Prototypen von JavaScript nutzen kann, außer sie zum Erstellen instanziierbarer und / oder gekapselter klassenähnlicher Blöcke zu verwenden (was für mich eher eine Problemumgehung als ein Vorteil zu sein scheint )

Andere JS-Funktionen wie Funktionen als Werte oder die logische Bewertung von Nicht-Booleschen Werten lassen sich viel einfacher in ...

Welche häufigen Programmierprobleme lassen sich am besten mit propotypischer Vererbung und Verschlüssen lösen?

1. Verschlüsse machen Funktionen als Werte nützlich. Wenn Sie die Funktion übergeben, benötigen Sie sie mit ziemlicher Sicherheit, um einen Kontext mitzunehmen. Welches ist genau das, was Verschlüsse tun.

2. Prototypen sind nur eine einfachere Version der Klassenvererbung. Anstatt Instanzen und Klassen zu haben (ohnehin durch spezielle Arten von Instanzen in dynamischen Sprachen dargestellt), haben Sie nur Instanzen und der Prototyp ist die Klasse (und sein Prototyp ist die Basisklasse). Sie lösen also im Grunde die gleichen Probleme, nur die Prototypen sind einfacher zu implementieren (deshalb hat JavaScript sie ausgewählt), etwas schwieriger zu verwenden (naja, nur Mangel an syntaktischem Zucker) und besser oder schlechter leichter zu missbrauchen.

Closures lösen keine Programmierprobleme, die ohne sie nicht gelöst werden können. Dies kann jedoch für alle Sprachfunktionen gesagt werden, die für die Vollständigkeit von Turing nicht benötigt werden, sodass es nicht viel bedeutet.

Überlegen Sie, wie Sie Code, der einen Abschluss verwendet, neu schreiben müssen, um keinen Abschluss zu verwenden. Sie würden der Funktion mit dem Abschluss wahrscheinlich zusätzliche Eigenschaften geben, damit sie ihren Status zwischen den Aufrufen beibehalten kann. Das würde nur bedeuten, dass die Variablen, die sich bereits im Gültigkeitsbereich befinden, in gleichnamige Eigenschaften der Funktion kopiert werden. Es wäre also eine sinnlose Tippübung, die Sie dazu bringt, den Bildschirm anzuschreien. "Warum kann der dumme Compiler nicht ( Dolmetscher, was auch immer) finden Sie das heraus? " Das sind Schließungen, der dumme Compiler ist klug genug, um es herauszufinden.

Abschlüsse eignen sich hervorragend für asynchrone Logik.

Für mich geht es hauptsächlich um die Organisation von Code. Es ist schön, eine Reihe lokaler Funktionen zu haben, um aufzuteilen, was der Code tut.

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

Hier ist ein weiteres Beispiel für eine Schließung

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

Und noch ein Beispiel

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

Die Alternative zur Verwendung von Verschlüssen besteht darin, Variablen mithilfe von Variablen in Funktionen zu curryen f.bind(null, curriedVariable).

Im Allgemeinen verwendet die asynchrone Programmierlogik jedoch Rückrufe, und die Manipulation des Status in Rückrufen beruht entweder auf Currying oder auf Schließungen. persönlich bevorzuge ich Verschlüsse.

Die Verwendung der prototypischen Vererbung ermöglicht OO? Muss die prototypische Vererbung wirklich mehr als das tun, damit sie als "nützlich" angesehen wird? Es ist ein Vererbungstool, es ermöglicht Vererbung, das ist nützlich genug.