相关疑难解决方法(0)

我编写的代码看起来像:

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构造函数反模式 ",这个代码有什么不好,为什么这被称为 …

我已经开发了几年的JavaScript,我根本不理解有关承诺的大惊小怪.

似乎我所做的只是改变:

api(function(result){
    api2(function(result2){
        api3(function(result3){
             // do work
        });
    });
});

无论如何,我可以使用像async这样的库,例如:

api().then(function(result){
     api2().then(function(result2){
          api3().then(function(result3){
               // do work
          });
     });
});

哪个代码更多,可读性更低.我没有在这里获得任何东西,它也不会突然神奇地"平坦".更不用说必须将事物转换为承诺.

那么,这里的承诺有什么大惊小怪？

使用ES6承诺,如何在不定义解析逻辑的情况下创建承诺？这是一个基本的例子(一些TypeScript):

var promises = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return promises[key];
  }
  var promise = new Promise(resolve => {
    // But I don't want to try resolving anything here :(
  });

  promises[key] = promise;
  return promise;
}

function resolveWith(key: string, value: any): void {
  promises[key].resolve(value); // Not valid :(
}

使用其他promise库可以轻松完成.以JQuery为例:

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = $.Deferred();    
  deferreds[key] = …

使用Promises时,为什么不能在代码库的其他地方触发resolve和reject定义？

我不明白为什么resolve和reject逻辑应该在声明promise的地方进行本地化.这是一种疏忽,还是强制要求executor参数？

我相信执行程序函数应该是可选的,并且它的存在应该确定promise是否封装了解决方案.如果没有这样的要求,承诺将更加可扩展,因为您不必立即启动异步.承诺也应该是可以重置的.它是一个1开关,1或0,resolve()或reject().有迹象表明,可附接的并行和串行结果众多:promise.then(parallel1)和promise.then(parallel2)并且也promise.then(seq1).then(seq2)但参考特权玩家无法解析/拒绝到交换机

您可以在以后构建结果树,但不能改变它们,也不能改变根(输入触发器)

老实说,连续结果的树也应该是可编辑的.假设你想要拼出一个步骤并在你宣布许多承诺链之后做其他事情.重建承诺和每个顺序功能是没有意义的,特别是因为你甚至不能拒绝或毁掉承诺......

现在看来,创建延迟对象通常不鼓励使用ES6风格的Promise构造函数.是否存在使用延迟需要(或者更好地某种方式)的情况？

例如,在此页面上,给出以下示例作为使用延迟的理由:

function delay(ms) {
    var deferred = Promise.pending();
    setTimeout(function(){
        deferred.resolve();
    }, ms);
    return deferred.promise;
}

但是,这可以使用Promise构造函数完成:

function delay(ms) {
    return new Promise(function(resolve, reject){
        setTimeout(function(){
            resolve();
        }, ms);
    });
}

使用ES2015，我是否可以从外部解决承诺，即在创建承诺后触发解决方案？

喜欢

const promise = new Promise();
promise.then(() => foo());
promise.resolve(); // foo() gets executed

我有一系列我想并行调用但同步解决的承诺。

我编写了这段代码来完成所需的任务，但是，我需要创建自己的对象QueryablePromise来包装Promise我可以同步检查以查看其已解决状态的本机对象。

有没有更好的方法来完成这个不需要特殊对象的任务？

请注意。我不想使用，Promise.all因为我不想在处理承诺的影响之前等待所有承诺解决。我不能async在我的代码库中使用函数。

const PROMISE = Symbol('PROMISE')
const tap = fn => x => (fn(x), x)

class QueryablePromise {
  resolved = false
  rejected = false
  fulfilled = false
  constructor(fn) {
    this[PROMISE] = new Promise(fn)
      .then(tap(() => {
        this.fulfilled = true
        this.resolved = true
      }))
      .catch(x => {
        this.fulfilled = true
        this.rejected = true
        throw x
      })
  }
  then(fn) {
    this[PROMISE].then(fn)
    return this
  }
  catch(fn) {
    this[PROMISE].catch(fn)
    return this
  }
  static resolve(x) …