经验法则

每当您对如何使用 Promise 做某事有疑问时 - 考虑一下同步版本。

try{
   var result = myFn(param);
   // business logic with result
} catch(e) {
    //error handling logic
}

至少在我看来，这比第一个参数有时为null.

Promise方式几乎总是与问题的同步版本非常相似：

myFn(param).then(function(result){
    // business logic with result
}).catch(function(e){
    //error handling logic
});

使用回调时 myFn 看起来像这样：

var myFn = function(param){
    return new Promise(function(resolve, reject){
        var calc = doSomeCalculation(param);
        if(calc === null) { // or some other way to detect error
            reject(new Error("error with calculation"), null);
        }
        someAsyncOp(calcN,function(err, finalResult){
            if(err) reject(err);
            resolve(finalResult);
        })
    });
};

使用回调/nodebacks

这只是你在使用回调时应该做的事情，当使用Promise时它要简单得多，你可以这样做：

var myFn = function(param){
    var calc = doSomeCalculation(param);
    ...
    return someAsyncOp(calcN); // returning a promise.
}

此外，在Promise链中工作时，您可以获得安全性：

myFn(param).then(function(calcN){
   // here, you throw to raise an error and return to resolve
   // new Promise should be used only when starting a chain.
}).catch(function(err){
    // handle error
}).then(function(){
   // ready to go again, we're out of the catch
});

请注意，一些库，如Bluebird、RSVP和Q提供了语法糖和方法的自动promisification，因此您很少需要new Promise自己使用。

另外，考虑阅读这个和那个以了解有关Promise错误处理的更多信息。

如果您使用 async/await 语法，则可以只使用常规的 try-catch 语法进行错误处理。

// your promise function
const myFn = function(param){
  return new Promise(function(resolve, reject){
      if (someLogic()) {
          resolve(someValue);
      } else {
          reject('failure reason');
      }
  });
}

// Define the parent function as an async function
async function outerFn(param) {
    try {
        // Wait for the promise to complete using await
        const result = await myFn(param)
        // business logic with result
    } catch (e) {
        //error handling logic
    }
}