Vragen van de synchrone node.js

Er zijn een paar ontwerppatronen die u in node.js kunt gebruiken om opeenvolgende asynchrone bewerkingen uit te voeren. In al deze gevallen kun je geen strakke lus draaien terwijl je wacht tot er iets gebeurt - je moet de enkele Javascript-thread in node.js laten draaien en deze zoveel mogelijk cycli geven.

Handmatige iteratie

Zet de code voor een iteratie in een lokale functie (ik noem het meestal next() ) en wanneer een iteratie zijn laatste voltooiingsfunctie aanroept, kunt u next() aanroepen om de volgende iteratie te starten. U kunt de bewerking voltooien door een voorwaarde te testen en niet next() . aan te roepen als dingen gedaan zijn of de eerste regels van next() kan testen of je klaar bent.

Zie het onderstaande codevoorbeeld voor hoe uw code eruit zou zien met handmatige iteratie.

Volgorde beloften

Als u beloften gebruikt voor uw asynchrone bewerkingen, kunt u geketende beloften al uw sequencing voor u laten doen zoals in p().then(f1).then(f2).then(f3) . Je kunt daar een voorbeeld van zien in dit antwoord:Belooft zoals async.each .

Gebruik de asynchrone module

De Async-module ondersteunt een aantal asynchrone beheerfuncties. Velen vinden het erg nuttig - anderen zouden liever beloften gebruiken om soortgelijke problemen op te lossen. Het heeft in ieder geval een aantal verschillende functies voor sequencing. Als u bijvoorbeeld een array asynchroon zou willen herhalen, zou u zoiets als dit gebruiken:

async.eachSeries(hugeArray, function iterator(item, callback) {
  if (inCache(item)) {
    callback(null, cache[item]); // if many items are cached, you'll overflow
  } else {
    doSomeIO(item, callback);
  }
}, function done() {
  //...
});

Hier is een versie van uw code die de handmatige iteratie uitvoert met behulp van een aangepaste next() iteratiefunctie.

function runQuery(callback) {
    mysql.getConnection(function(err, connection) {
        if (err) {
            connection.release();
            callback(err);
            return;
        }

        var array = [];
        var count = 10;
        var index = 0;

        function next() {
            if (index++ < count) {
                array.push([index, 'master']);
                console.log('100-elements');
                connection.beginTransaction(function(err) {
                    if (err) {
                        // can't throw here in an async function
                        // use callback to communicate error
                        callback(err);
                        return;
                    }

                    var query = "insert into users(username, password) values ?";
                    connection.query(query, [array], function(err, rows) {

                        if (!err) {
                            //commit start
                            connection.commit(function() {
                                if (err) {
                                    console.error(err);
                                    connection.rollback(function() {
                                        console.error('rollback error');
                                        callback(err);
                                        return;
                                    });
                                } else {
                                    console.log("Commit");
                                    // now do the next iteration
                                    next();
                                } // if err
                            }); //commit end
                        } else {
                            console.log(err);
                            connection.rollback(function() {
                                callback(err);
                                return;
                            });
                        } // if                    
                    });
                });
            }
        }
    });
}