Javascript 如何转换链'；将s承诺转换为Q和打字脚本中的扁平承诺_Javascript_Node.js_Typescript_Q

Javascript 如何转换链'；将s承诺转换为Q和打字脚本中的扁平承诺

javascript node.js typescript

Javascript 如何转换链'；将s承诺转换为Q和打字脚本中的扁平承诺,javascript,node.js,typescript,q,Javascript,Node.js,Typescript,Q,我想知道是否有一种方法可以将chain的承诺转换为扁平承诺。我有以下代码： import * as Q from 'q'; export class MyClass { private methodA(): Q.Promise<boolean> { let deferred = Q.defer<boolean>(); //some stuff, like database calls, etc return deferred.promise;

我想知道是否有一种方法可以将chain的承诺转换为扁平承诺。我有以下代码：

import * as Q from 'q';
export class MyClass {

  private methodA(): Q.Promise<boolean> {
    let deferred = Q.defer<boolean>();
    //some stuff, like database calls, etc
    return deferred.promise;
  }

  private methodB(): Q.Promise<boolean> {
    let deferred = Q.defer<boolean>();
    //some stuff, like database calls, etc
    return deferred.promise;
  }

  private methodC(): Q.Promise<boolean> {
    let deferred = Q.defer<boolean>();
    //some stuff, like database calls, etc
    return deferred.promise;
  }

  private methodD(): Q.Promise<boolean> {
    let deferred = Q.defer<boolean>();
    //some stuff, like database calls, etc
    return deferred.promise;
  }

  run(): Q.Promise<boolean> {
    let deferred = Q.defer<boolean>();
    let promises = [];

    promises.push(this.methodA().then(wasOk => {
      this.methodB().then(wasOk => {
        this.methodC();
      });
    }));

    promises.push(this.methodD());

    //Wait all promises
    Q.all(promises).then(wasOk => deferred.resolve(wasOk));

    return deferred.promise;
  }
}

import*作为Q从'Q'导入；
导出类MyClass{
私有方法a（）：Q.承诺{
设deferred=Q.deferred（）；
//一些东西，比如数据库调用，等等
回报。承诺；
}
私有方法b（）：Q.承诺{
设deferred=Q.deferred（）；
//一些东西，比如数据库调用，等等
回报。承诺；
}
私有方法c（）：Q.承诺{
设deferred=Q.deferred（）；
//一些东西，比如数据库调用，等等
回报。承诺；
}
私有方法d（）：Q.承诺{
设deferred=Q.deferred（）；
//一些东西，比如数据库调用，等等
回报。承诺；
}
run（）：Q.承诺{
设deferred=Q.deferred（）；
让承诺=[]；
promises.push（this.methodA（）.then（wasOk=>{
this.methodB（）.then（wasOk=>{
方法c（）；
});
}));
promises.push（this.methodD（））；
//等待所有的承诺
然后（wasOk=>deferred.resolve（wasOk））；
回报。承诺；
}
}

这段代码有一个问题：Q.all只等待methodA和methodD；而不是等待methodB和methodC

我想我需要把方法B和C放在promises的向量中，或者甚至做另一个向量，然后在第一个Q中等待它。。。但它不是一个清晰的代码，我想知道是否有更好的方法

非常感谢

您有一个小错误，几乎是打字错误：

promises.push(this.methodA().then(wasOk => {
      this.methodB().then(wasOk => {
        this.methodC();
      });
    }));

这是花括号——它们将承诺的回报变成了未定义的回报。您可以这样做：

promises.push(this.methodA().then(wasOk => 
      this.methodB().then(wasOk => 
        this.methodC();
      );
    ));

或者这个：

promises.push(this.methodA().then(wasOk => {
      return this.methodB().then(wasOk => {
        return this.methodC();
      });
    }));

甚至这个：

promises = [this.methodA(), this.methodB(), this.methodC()];

您有一个小错误，几乎是打字错误：

promises.push(this.methodA().then(wasOk => {
      this.methodB().then(wasOk => {
        this.methodC();
      });
    }));

这是花括号——它们将承诺的回报变成了未定义的回报。您可以这样做：

promises.push(this.methodA().then(wasOk => 
      this.methodB().then(wasOk => 
        this.methodC();
      );
    ));

或者这个：

promises.push(this.methodA().then(wasOk => {
      return this.methodB().then(wasOk => {
        return this.methodC();
      });
    }));

甚至这个：

promises = [this.methodA(), this.methodB(), this.methodC()];

您只是在

methodA

上的

then

处理程序中缺少了一个

return

，并且可能在其

then

处理程序中，因为您使用的是详细的箭头函数：

promises.push(this.methodA().then(wasOk => {
  return this.methodB().then(wasOk => {
//^^^^^^^
    return this.methodC();
//  ^^^^^^^
  });
}));

promises.push(this.methodA().then(wasOk => this.methodB().then(wasOk => this.methodC())));

或使用简洁的箭头功能：

promises.push(this.methodA().then(wasOk => {
  return this.methodB().then(wasOk => {
//^^^^^^^
    return this.methodC();
//  ^^^^^^^
  });
}));

promises.push(this.methodA().then(wasOk => this.methodB().then(wasOk => this.methodC())));

或者使用带换行符的简明箭头：

promises.push(this.methodA().then(wasOk =>
  this.methodB().then(wasOk =>
    this.methodC()
  )
));

请注意，该代码执行以下操作：

调用
```
methodA
```
并等待其解决，然后
调用
```
methodB
```
并等待其解决，然后
调用
```
methodC
```

因此，总的来说，数组中的第一个承诺只有在

methodB

和

methodC

解析后才能解析

methodD

立即被调用，因此可以更快地解决问题

阵列结构也可以更简单：

promises = [
  this.methodA().then(wasOk =>
    this.methodB().then(wasOk =>
      this.methodC()
    )
  ),
  this.methodD()
];