Выполнение серийного кода Node.js

Question

Итак, я недавно начал играть с Node.js, который показал мне асинхронный код так, как я его видел раньше. Однако проблема, с которой я сталкиваюсь, заключается в том, что узел узла выполняет почти функции, вызываемые асинхронно (если я правильно понимаю). Таким образом, у меня есть две функции: A, B, которые выполняют некоторые действия с базой данных. Функция A должна быть выполнена до того, как начнется B. Однако я понял, что просто позвонить A после B явно не разрезал. Поэтому я думаю, что узел должен сделать обратный вызов :). Но у моего приложения с продукцией, вероятно, будет серия с А до Я, чтобы можно было запутаться. Однако я был бы очень признателен за пример того, как реализовать такой обратный вызов в node.js.

var http = require('http'); 

function runAllFunc() { 
    funcA(); 
    funcB(); 
}; 

var server = http.createServer(function(req,res) { 
    syncFunc(); 
    res.writeHead(200, {'Content-Type':'text/plain'}); 
    res.end('dde'); 
}).listen(8080); 

Answer 1

Есть несколько способов сделать это.

Вы можете использовать обратные вызовы. Я не знаю, что делают ваши функции, поэтому мои примеры ниже будут тривиальными примерами async, использующими setTimeout.

function doFirstThing(callback) { 
    setTimeout(function() { 
    console.log('First Thing is done'); 
    if (callback) { 
     callback(); 
    } 
    }, 1000); 
} 
function doSecondThing(callback) { 
    setTimeout(function() { 
    console.log('Second Thing is done'); 
    if (callback) { 
     callback(); 
    } 
    }, 1000); 
} 

doFirstThing(doSecondThing); 

Вы можете также использовать обещание, Bluebird (https://github.com/petkaantonov/bluebird) и Q (https://github.com/kriskowal/q) две библиотеки, которые приходят на ум. Вот пример с Q.

var Q = require('q'); 
function doFirstThing() { 
    var deferred = Q.defer(); 
    setTimeout(function() { 
    console.log('First Thing is done'); 
    deferred.resolve(); 
    }, 1000); 
    return deferred.promise; 
} 
function doSecondThing() { 
    var deferred = Q.defer(); 
    setTimeout(function() { 
    console.log('Second Thing is done'); 
    deferred.resolve(); 
    }, 1000); 
    return deferred.promise; 
} 

doFirstThing().then(doSecondThing).done(); 

Другим вариантом является async модуль (https://github.com/caolan/async). Вот пример:

var async = require('async'); 
function doFirstThing(next) { 
    setTimeout(function() { 
    console.log('First Thing is done'); 
    next(); 
    }, 1000); 
} 
function doSecondThing(next) { 
    setTimeout(function() { 
    console.log('Second Thing is done'); 
    next() 
    }, 1000); 
} 

async.series([doFirstThing, doSecondThing]); 

Конечно, есть много различных способов настройки ваших обратных вызовов, используя вашу библиотеку Promise, или рабочих процессов с асинхронным. Это всего лишь несколько примеров.

EDIT: Отредактировано для включения ссылок на ссылки библиотек.

Answer 2

Если вы просто соединяете две функции вместе, я бы использовал традиционный обратный вызов. Но если у вас будет куча, зависящая от разных комбинаций друг друга, я бы порекомендовал асинхронный модуль. (https://github.com/caolan/async)

Вот как вы могли бы сделать приведенный выше пример.

var async = require('async'); 

var funcA = function() { 
    console.log("I am function 1"); 
}; 

var funcB = function() { 
    console.log("I am function 2"); 
}; 

async.auto({ 
    funcA: function(onADone) { 
    funcA(); // call your first function here 
    onADone(); // callback 
    }, 
    funcB: ['funcA', function(onBDone) { 
    // second function will not execute until first one is done 
    // because it is specified above 
    funcB(); 
    onBDone(); // callback 
    }], 
}, function(err, res) { 
    if (err) { 
    console.log("something went wrong " + err); 
    } else { 
    console.log("done"); 
    } 
});