Ich betrachte mich als einen sehr erfahrenen node.js-Entwickler.

Aber ich frage mich immer noch, ob es einen besseren Weg gibt, den folgenden Code zu schreiben, damit ich die Pyramide des Schicksals nicht bekomme ... Jetzt habe ich dich geschont, ich habe einen Code, den meine Pyramide 20 Stockwerke hoch bekommt. Im Ernst; und das ist WITH using async.js !!!

Das Problem ist wirklich, dass ich viele Abhängigkeiten von Vorschau-Variablen habe, also muss alles verschachtelt sein. Der Typ, der das Buch "Async Javascript, mehr reaktionsschnelle Apps mit weniger Code erstellen" geschrieben hat, erklärt, dass er die Funktionen in den Root-Bereich stellen würde, was sicher die Pyramide loswerden würde, aber jetzt hätten Sie eine ganze Reihe von Highs Bereichsvariablen (möglicherweise sogar global, abhängig von dem Bereich, in dem Sie sie deklarieren) und diese Verschmutzung können zu ziemlich üblen Fehlern führen (dies kann zu var-Konflikten mit anderen Skripten führen, wenn sie auf globaler Ebene festgelegt werden (Sie können sicher sein, dass Sie selbstaufrufende Funktionen verwenden)) yachhh ... oder noch schlimmer, da es sich um asynchrone, variable Overrides handelt ...) Tatsächlich ist die Schönheit des Schließens ziemlich breii

Was er empfiehlt, macht so etwas wie:

function checkPassword(username, passwordGuess, callback) {
    var passwordHash;
    var queryStr = 'SELECT * FROM user WHERE username = ?';
    db.query(selectUser, username, queryCallback);
    function queryCallback(err, result) {
        if (err) throw err;
        passwordHash = result['password_hash'];
        hash(passwordGuess, hashCallback);
    }

    function hashCallback(passwordGuessHash) {
        callback(passwordHash === passwordGuessHash);
    }
}

ieder, kein sauberer Ansatz IMHO.

Also, wenn Sie sich meinen Code ansehen (wieder ist dies nur ein Ausschnitt, ich bekomme viel größere Nester an anderen Stellen), werden Sie oft sehen, dass mein Code immer weiter von der linken Seite abweicht; und das ist mit Dingen wie Wasserfall und asynchrone forEach ...

hier ist ein kleines Beispiel:

ms.async.eachSeries(arrWords, function (key, asyncCallback) {
    pg.connect(pgconn.dbserver('galaxy'), function (err, pgClient, pgCB) {
        statement = "SELECT * FROM localization_strings WHERE local_id = 10 AND string_key = '" + key[0] + "'";
        pgClient.query(statement, function (err, result) {
            if (pgconn.handleError(err, pgCB, pgClient)) return;
            // if key doesn't exist go ahead and insert it
            if (result.rows.length == 0) {
                statement = "SELECT nextval('last_resource_bundle_string_id')";
                pgClient.query(statement, function (err, result) {
                    if (pgconn.handleError(err, pgCB, pgClient)) return;
                    var insertIdOffset = parseInt(result.rows[0].nextval);
                    statement = "INSERT INTO localization_strings (resource_bundle_string_id, string_key, string_revision, string_text,modified_date,local_id, bundle_id) VALUES ";
                    statement += "  (" + insertIdOffset + ",'" + key[0] + "'," + 0 + ",'" + englishDictionary[key[0]] + "'," + 0 + ",10,20)";
                    ms.log(statement);
                    pgClient.query(statement, function (err, result) {
                        if (pgconn.handleError(err, pgCB, pgClient)) return;
                        pgCB();
                        asyncCallback();
                    });
                });
            }
            pgCB();
            asyncCallback();
        });
    });
});

In meinen tiefen Skripten habe ich mehr als 25 schließende Klammern, CRAZY, gezählt und mich dabei immer wieder daran erinnert, wo ich mein letztes callBack aufrufen soll, damit die Asynchronisierung mit der nächsten Iteration fortgesetzt wird ...

Gibt es eine Lösung für dieses Problem? Oder ist es nur die Natur des Tieres?