何时使用Promises推迟功能

Question

我将Q节点库用于Promises，我认为这个问题也适用于Bluebird库。

语境

我需要对自己的自定义函数和node.js fs样式异步函数进行一些函数调用。

如果我正在调用这样的函数：

同步功能

do_something = function (input) {
  // assign variables, do other sync stuff 
}

并需要以上内容来执行before此功能：

同步功能

do_something_else = function (input) {
  // assign variable, do other sync stuff
}

并且then需要调用类似于以下内容的本机节点函数：

异步功能

writeData = function (obj, callback) {
  var deferred = Q.defer();
  fs.writeFile(obj.file, obj.datas, function (err, result) {
    if (err) deferred.reject(err);
    else deferred.resolve('write data completed');
  });
  return deferred.promise.nodeify(callback);
}

并finally需要以上内容来执行before此功能：

同步功能

do_something_last = function (input) {
  // assign variable, do other sync stuff
}

题

为了使我的所有函数“递延”或答应知道，在这里要做的“正确”事情是什么，以便确保可以按顺序或以正确的顺序调用它们？像这样：

do_something(variable)
.then(do_something_else)
.then(writeData)
.then(do_something_last)
.done();

还是应该代替它并保持顺序（排序）？像这样：

var variable1 = 'test1.txt'
var variable2 = 'test2.txt'
var return_value = do_something(variable1);
var return_another_value = do_something_else(return_value); <--sync
writeData(return_another_value); <-- async function
var final_value = do_something_last(variable2);  <-- sync function
// could potentially have async calls again after a sync call
writeDataAgain(return_another_value); <-- async function

澄清说明

我的想法是，由于其中一些同步函数将需要在异步之后被触发，因此我需要使它们对Promise有所了解，以便保持顺序的顺畅，如下所示：

同步功能使承诺意识到

do_something = function (input) {
  var deferred = Q.defer();
  // assign variables, do other sync stuff 
  deferred.resolve(_output_result_);
  return deferred.promise;
}
do_something_else = function (input) {
  var deferred = Q.defer();
  // assign variables, do other sync stuff 
  deferred.resolve(_output_result_);
  return deferred.promise;
}
do_something_last = function (input) {
  var deferred = Q.defer();
  // assign variables, do other sync stuff 
  deferred.resolve('completed workflow');
  return deferred.promise;
}

这将允许我执行以下操作：

do_something(variable)
.then(do_something_else) <-- these need to execute before writeData
.then(writeData) <-- a async node fs call to writeFile
.then(do_something_last) <-- I need this to happen after the writeDate
.done();

阅读完反馈后，我想我真正要问的是：

如何创建函数工作流，混合非承诺同步和承诺感知的异步函数调用，同时保持执行的顺序（或顺序）？

Answer 1

只需这样做，并保持顺序如下：

writeData(return_another_value);
var final_value = do_something_last(variable2);

嗯，这根本就行不通，因为do_something_last在writeData(…)诺言 解决
之后就没有这样说。它会在创建并返回承诺后立即开始。因此，如果您关心该特定顺序并想等到数据写入后，则 需要 使用then回调：

var final_promise = writeData(return_another_value).then(function(writeResult) {
    return do_something_last(variable2);
});

一般规则是：

• 使同步功能同步-无需承诺
• 使所有异步函数始终返回承诺
• 仅在可能的最低级别使用延期付款

您可以将 同步函数放在then链中，非承诺的返回值（甚至抛出的异常）在它们中可以正常工作。因此，尽管您 可以 像这样写序列

Q('test1.txt')
.then(do_something)
.then(do_something_else)
.then(writeData)
.then(do_something_last.bind(null, 'test2.txt'))
.done();

看起来很奇怪。如果您do_something出于某种原因不打算在不久的将来使s异步，那么编写和阅读通常会更简单

writeData(do_something_else(do_something('test1.txt'))).then(function() {
    return do_something_last('test2.txt');
}).done();

诚然，有时写起来更具吸引力

somePromise()
.then(doSomethingSynchronous)
.then(doSomethingAsynchronous)

比

somePromise
.then(function(res) { return doSomethingAsynchronous(doSomethingSynchronous(res)); })

即使它们在 功能上相同 。选择您更喜欢且更一致的样式。