Typescript 遍历方法调用序列的Promise对象（作为返回类型）

有一种古老/经典的方法-方法返回其他方法调用的结果：

method1(): ObjectX {
   if( condition1 )
      return method2();

   return undefined // or some default value;
}

method2(): ObjectX {
  let res: ObjectX;
  // some IO operations
  return res;
}

现在我想使用

Promise

作为method2的返回类型（例如，因为存在一些IO操作）

因此，方法2变成：

method2() : Promise<ObjectX> {
  return new Promise((resolve)=> {
     let res: ObjectX;
     // some IO operations
     resolve(res);
  })
}

method2（）：承诺{
返回新承诺（（解决）=>{
let res:ObjectX；
//一些IO操作
决议（res）；
})
}

问题在于方法1

为什么不能是这样的:

method1() : Promise<ObjectX> {
   if( condition1) 
      return this.method2(); 

   return new Promise((reject)=> { reject(‘error’); })
}

method1（）：承诺{
如果（条件1）
返回这个.method2（）；
返回新承诺（（拒绝）=>{reject（'error'）；}）
}

为什么一个需要返回承诺的方法不能返回另一个方法（类似的承诺）的结果

为什么它必须“打开”收到的承诺，拿出结果并用这个结果解决它自己的承诺

像这样：

method1() : Promise<ObjectX> {
    return new Promise((resolve, reject) => {
       if( condition1) 
          method2().then( (r) => resolve(r) ); // take out the result from received promise and resolve my own promise :(

       reject(‘error’); 
    });

method1（）：承诺{
返回新承诺（（解决、拒绝）=>{
如果（条件1）
method2（）。然后（（r）=>resolve（r））；//从收到的承诺中取出结果并解决我自己的承诺：(
拒绝（“错误”）；
});

}

我的意思是这是可行的，但我想理解为什么以前的方法1不起作用

更一般地说，假设我有一个相互调用并返回对象的方法序列（返回对象遍历该序列）。如果我在最后一个方法中引入一个承诺-作为结果类型，我必须大量修改序列中所有方法的代码，而不仅仅是签名和返回语句

---

还是有其他技术可以实现这一点？

您的最终

方法1

过于复杂：

method1() {
   if(condition1) 
      return Promise.resolve(method2());
   return Promise.reject(‘error’); 
}

async method1() {
   if(condition1) 
      return method2();
   throw 'error';
}

不需要返回类型：typescript将正确地计算出它是

Promise

但即使这样也过于复杂：

method1() {
   if(condition1) 
      return Promise.resolve(method2());
   return Promise.reject(‘error’); 
}

async method1() {
   if(condition1) 
      return method2();
   throw 'error';
}

同样地，

method1

具有正确的返回类型

Promise

无论是

method2（）

返回

ObjectX

还是

Promise

，这两者都是一样的。您不应该仅仅为了返回其值而“打开”一个承诺，只需将它包装成一个新的承诺，或者使用

Promise.resolve（）

显式地，或者使用

async

隐式地

此操作有效的原因以及使用此操作的代码不起作用的原因：

return new Promise((reject)=> { reject(‘error’); })

您的新承诺返回类型为

promise

，但返回类型为

promise。拒绝（某物）

类型为

promise

当这些与您的

Promise

组合时，第一个代码给出了一个推断返回类型

Promise

，该类型不能分配给

Promise

，而是使用

Promise.reject（）

为您提供了

Promise

，它简化为

Promise

，因为当您组合这些类型时，

never

类型将消失

如果您更改了不起作用的代码，您可以自己看到这一点，因为此变体可能会起作用：

return new Promise<never>((reject)=> { reject(‘error’); })

返回新承诺（（拒绝）=>{reject（'error'）；}）