试着在承诺中抓住机会

Question

我需要编写一个返回承诺的函数，其中首先调用一个返回某些结果的同步函数A()。然后返回函数B(结果)，其中B是接受A()结果的承诺。如果任何一个函数失败，我希望调用相同的错误函数C( error )，其中C是一个承诺。写这篇文章的最佳方式是什么。这是我所拥有的，但我认为有明显的方式我错过了。

function() {
    try {
        var result = A();
        return B(result)
            .catch(function(error) {
                return C(error);
            });
     }
     catch(error) {
         return C(error);
     }
}

将同步尝试和捕获与承诺.catch相结合似乎是错误的，也是错误的--我需要调用C(错误)的两个不同地方。

一个()抛出一个错误，而不是返回一个错误代码。

Answer 1

您没有确切地说明A()是如何失败的。它可以抛出，也可以返回错误结果。我会给你们看一个方案。同步和异步混合的关键是始终返回承诺。这将为teh调用方提供一个一致的接口，无论该函数如何成功或失败。

如果您只担心A()抛出一个异常，并且它不返回错误代码，那么您可以这样做：

function someFunction() {
    try {
        var result = A();
        return B(result);
     } catch(err) {
         return Promise.reject(err);
     }
}

someFunction().then(function(result) {
    // code here to process the final result
}).catch(C);

如果您还有A()可以返回错误代码的情况，那么您可以这样做：

function someFunction() {
    try {
        var result = A();
        // check for error value
        if (result < 0) {
            throw result;
        }
        return B(result);
     } catch(err) {
         return Promise.resolve(err);
     }
}

请注意，这两种模式都避免在不需要的情况下创建额外的承诺。它们只在返回同步发生的错误时才创建额外的承诺。

对于这种特殊情况，蓝鸟承诺库有一个名为Promise.method的助手函数。Promise.method()的实用功能是它将函数自动包装在try/catch处理程序中，如果抛出任何同步异常，它会自动将它们转换为返回拒绝的承诺。你可以这样用它：

var someFunction = Promise.method(function() {
    var result = A();
    // check for error condition
    if (result < 0) {
        throw result;
    }
    return B(result);
});

someFunction().then(function(result) {
    // code here to process the final result
}).catch(C);

Answer 2

我假设A和B都可以在这里抛出错误。使用标准API，它可以如下所示：

function() {
  return new Promise((resolve, reject) => {
    try {
      resolve(A());
    } catch (error) {
      reject(error);
    }
  })
  .then(B)
  .catch(C);  
}

这将返回一个承诺，这个承诺要么用B的输出解决，要么返回C的输出，如果这提供了一个退路。如果这对您的用例有意义的话，您也可以考虑处理此函数之外的任何错误。

当使用蓝知更鸟时，这也是可能的：

function() {
  return Promise.method(A)().then(B).catch(C)
}

Answer 3

我认为这样做的一个好方法是仍然使用同步函数的承诺。它使它在函数中保持一致，特别是当你想要对成功做出反应的时候，比如一个虚假的承诺。但关键是你要用一个立竿见影的承诺。看看这个关于ES6承诺的博客文章。

// an immediately resolved promise
var a = Promise.resolve(A());

假设您已经创建了承诺并定义了C，如下所示：

var B = new Promise(function(resolve, reject) {  
   if (a) {
      resolve('success');  // fulfilled successfully
   }
   else {
      C('rejected');  // error, rejected
   }
})
.then((result) => {console.log('made it!');})
.catch((result) => {C('rejected');});

var C = (err)=>{console.log('error: ' + err); return err;}

这段代码应该做您想做的事情：

a.then((result) => B(result));

^这最后一行是最重要的，因为它使用A的输出调用B