什么是明确的承诺构建反模式,我该如何避免它？

Question

我编写的代码看起来像:

function getStuffDone(param) {           | function getStuffDone(param) {
    var d = Q.defer(); /* or $q.defer */ |     return new Promise(function(resolve, reject) {
    // or = new $.Deferred() etc.        |     // using a promise constructor
    myPromiseFn(param+1)                 |         myPromiseFn(param+1)
    .then(function(val) { /* or .done */ |         .then(function(val) {
        d.resolve(val);                  |             resolve(val);
    }).catch(function(err) { /* .fail */ |         }).catch(function(err) {
        d.reject(err);                   |             reject(err);
    });                                  |         });
    return d.promise; /* or promise() */ |     });
}                                        | }

有人告诉我这个被称为" 延迟反模式 "或" Promise构造函数反模式 ",这个代码有什么不好,为什么这被称为反模式？

Answer 1

Esailija创造的延迟反模式(现在是明确构建的反模式)是一种常见的反模式人物,他们是新的承诺,我在我第一次使用承诺时自己创造了.上述代码的问题在于无法利用promises链的事实.

承诺可以链接,.then你可以直接返回承诺.您的代码getStuffDone可以重写为:

function getStuffDone(param){
    return myPromiseFn(param+1); // much nicer, right?
}

Promise都是为了使异步代码更具可读性,并且表现得像同步代码而不隐藏这一事实.Promise表示对一次操作的值的抽象,它们在编程语言中抽象出语句或表达式的概念.

在将API转换为promises并且无法自动执行时,或者当您编写更容易表达的聚合函数时,您应该只使用延迟对象.

引用Esailija:

这是最常见的反模式.当你不真正理解承诺并将它们视为美化事件发射器或回调实用程序时,很容易陷入这种情况.让我们回顾一下:promises是关于使异步代码保留同步代码的大部分丢失属性,例如扁平缩进和一个异常通道.

Answer 2

它出什么问题了？

但模式有效!

幸运的你.不幸的是,它可能没有,因为你可能忘记了一些边缘情况.在我看过的一半以上的事件中,作者忘记了处理错误处理程序:

return new Promise(function(resolve) {
    getOtherPromise().then(function(result) {
        resolve(result.property.example);
    });
})

如果另一个承诺被拒绝,这将被忽视,而不是传播到新的承诺(它将被处理) - 并且新承诺永远保持未决,这可能导致泄漏.

在您的回调代码导致错误的情况下会发生同样的事情 - 例如,当result没有a property并且抛出异常时.那将是未经处理的,并且未能解决新的承诺.

相反,using .then()会自动处理这两种情况,并在发生错误时拒绝新的承诺:

 return getOtherPromise().then(function(result) {
     return result.property.example;
 })

延迟反模式不仅麻烦,而且容易出错.使用.then()的链接是安全得多.

但我处理了一切!

真？好.但是,这将非常详细和丰富,特别是如果您使用支持其他功能(如取消或消息传递)的promise库.或者也许它将来,或者你想要将你的图书馆换成更好的图书馆？您不希望为此重写代码.

库的方法(then)不仅本身支持所有功能,它们也可能具有某些优化.使用它们可能会使您的代码更快,或者至少可以通过库的未来版本进行优化.

我该如何避免呢？

因此,每当您发现自己手动创建Promise或Deferred已经存在的承诺时,请首先检查库API.递延反模式经常被人谁看到诺言[唯一]作为一个观察者模式应用-但承诺是更比回调:他们应该是组合的.每个体面的图书馆都有许多易于使用的功能,以各种可想象的方式构成承诺,照顾你不想处理的所有低级别的东西.

如果您发现需要以现有帮助函数不支持的新方式编写某些promise,那么使用不可避免的Deferreds编写自己的函数应该是最后一个选项.考虑切换到功能更强大的库,和/或针对当前库提交错误.它的维护者应该能够从现有函数派生组合,为您实现一个新的辅助函数和/或帮助识别需要处理的边缘情况.

Answer 3

现在 7 年后，这个问题有了更简单的答案：

如何避免显式构造函数反模式？

使用async functions，然后await每一个 Promise！

而不是像这样手动构建嵌套的 Promise 链：

function promised() {
  return new Promise(function(resolve) {
    getOtherPromise().then(function(result) {
      getAnotherPromise(result).then(function(result2) {
        resolve(result2);
      });
    });
  });
}

只需转动您的函数async并使用await关键字停止函数的执行，直到 Promise 解决：

async function promised() {
   const result =  await getOtherPromise();
   const result2 = await getAnotherPromise(result);
   return result2;
}

这有多种好处：

• 调用该async函数总是返回一个 Promise，它使用返回的值进行解析，如果在 async 函数中抛出错误则拒绝
• 如果awaited Promise 拒绝，错误会在异步函数中抛出，因此您可以try { ... } catch(error) { ... }像同步错误一样使用它。
• 你可以 await在循环和 if 分支中，使大部分 Promise 链逻辑变得微不足道
• 尽管异步函数的行为大多类似于 Promise 链，但它们更易于阅读（也更易于推理）

我怎样才能await回电？

如果回调只回调一次，并且您正在调用的 API 尚未提供 Promise（大多数都提供！），这是使用 Promise 构造函数的唯一原因：

 // Create a wrapper around the "old" function taking a callback, passing the 'resolve' function as callback
 const delay = time => new Promise((resolve, reject) =>
   setTimeout(resolve, time)
 ); 

 await delay(1000);

如果await停止执行，调用aasync function是否直接返回结果？

不。如果你调用一个异步函数，一个 Promise 总是会返回。然后await，您也可以在异步函数中使用该 Promise。您不能等待同步函数内的结果（您必须调用.then并附加回调）。

从概念上讲，同步functions 总是在一个作业中运行到完成，而async functions 同步运行直到它们到达await，然后它们继续在另一个作业中。