Typescript for循环中的Promise数组-第二次迭代时为空

我一直在试图理解使用for循环实现一系列承诺的正确方法。在我的代码中，我的数组有3个元素，但它只有第一次通过循环时才有数据

  private populateRequest(connection: Connection, myArray: any[], containerId: string): Promise<void> {
    // tslint:disable-next-line:no-shadowed-variable
    return new Promise(async (resolve, reject) => {
      const promises: Array<Promise<SomeType>> = [];
      let status = '';

      // tslint:disable-next-line:prefer-for-of
      for (let i = 0; i < myArray.length; i++) {
        const data = await this.getResolvedPromise(myArray[i])
        .then(response => response)
        .catch(err => console.log(err));
        if (this.flags.hasOwnProperty('prop1')) {
          status = 'Active';
        } else if (this.flags.hasOwnProperty('prop2')) {
          status = 'Inactive';
        } else if (data[0]['WidgetProp1'] === 'Active') {
          status = 'Inactive';
        } else if (data[0]['WidgetProp1'] === 'Inactive') {
          status = 'Active';
        }

        const myMetaObj = {
          prop3: data[0]['WidgetProp3'],
          status
        };
        const myMetaMember = {
          ContainerId: containerId,
          ContentEntityId: data[0]['WidgetId'],
          Body: data[0]['WidgetBody'],
          Metadata: myMetaObj
        };

        promises.push(myMetaMember);
      }

      Promise.all(promises)
        .then(() => resolve())
        .catch(err => reject(err));
    });
  }

  private getResolvedPromise(target: Promise<any>): Promise<any> {
    // tslint:disable-next-line:no-any
    return new Promise((resolve, reject) => {
    // tslint:disable-next-line:no-any
    Promise.all([target])
     .then(() => resolve(target))
     .catch(err => reject(err));
    });
  }

private-populateRequest（连接：连接，myArray:any[]，容器ID:string）：承诺{
//tslint:禁用下一行：无阴影变量
返回新承诺（异步（解析、拒绝）=>{
常量承诺：数组=[]；
让状态=“”；
//tslint:禁用下一行：首选
for（设i=0；i响应）
.catch（err=>console.log（err））；
if（this.flags.hasOwnProperty（'prop1'））{
状态='活动'；
}else if（this.flags.hasOwnProperty（'prop2'））{
状态=‘不活动’；
}否则如果（数据[0]['WidgetProp1']='Active'）{
状态=‘不活动’；
}否则如果（数据[0]['WidgetProp1']='Inactive'）{
状态='活动'；
}
常量myMetaObj={
prop3:数据[0]['WidgetProp3']，
地位
};
常量myMetaMember={
集装箱船，
ContentEntityId:数据[0]['WidgetId']，
正文：数据[0]['WidgetBody']，
元数据：myMetaObj
};
promises.push（myMetaMember）；
}
所有（承诺）
。然后（（）=>resolve（））
.catch（err=>reject（err））；
});
}
私有getResolvedPromise（目标：Promise）：Promise{
//tslint:禁用下一行：无任何
返回新承诺（（解决、拒绝）=>{
//tslint:禁用下一行：无任何
承诺。所有（[目标]）
。然后（（）=>解析（目标））
.catch（err=>reject（err））；
});
}

推送在第一次时按预期工作，但随后不按预期工作

我知道这是因为异步代码和调用没有完成，但不确定为什么我的

Promise.all（）

不能正常工作

---

哈尔普斯？

我真的搞不懂你的例子。但我看到的是，您正在使用

wait

，它同步解析

getResolvedPromise

中的承诺。您还使用了

。然后将
与wait结合使用，这没有意义，因为它做的是同一件事，但只是以另一种样式“wait”。因此，你要么：

const data = await promise;
// data is resolved here

或

如果必须使用for循环迭代结构，而不是使用
.map
，我建议您这样做：

async someFunction(): Promise<any[]> { 
  promises: Promise<any>[] = []
  for(const value of list) {
    promises.push(new Promise((resolve, reject) => {
      const data = await something
      // do something with data
      const fancyObject = {}
      resolve(fancyObject);

  }));
  return Promise.all(promises);
}


async someFunction（）：Promise{
承诺：承诺[]=[]
for（列表的常量值）{
承诺。推送（新承诺（（解决、拒绝）=>{
const data=等待某事
//处理数据
常量fancyObject={}
解决（fancyObject）；
}));
返回承诺。全部（承诺）；
}

您可以看到，依赖于数据对象的逻辑仅在通过
await
运算符解析承诺后运行。因此，此逻辑需要包装在承诺本身中

Promise.all
本身返回一个Promise，因此您不需要将其包装在另一个Promise中，并解析为包含所有FancyObject的数组。
还要注意，wait语法需要try-catch块，以便在promise解析时捕获发生的错误

我希望我正确地理解了你，你能对我的例子有所了解。
我真的无法理解你的例子。但我看到的是，你正在使用
wait
，它同步解析
getResolvedPromise
中的承诺。你也在使用
。然后
与wait一起使用，它没有意义因为它做同样的事情，但只是以另一种风格“等待”。因此，您可以：

const data = await promise;
// data is resolved here

或

如果必须使用for循环迭代结构，而不是使用
.map
，我建议您这样做：

async someFunction(): Promise<any[]> { 
  promises: Promise<any>[] = []
  for(const value of list) {
    promises.push(new Promise((resolve, reject) => {
      const data = await something
      // do something with data
      const fancyObject = {}
      resolve(fancyObject);

  }));
  return Promise.all(promises);
}


async someFunction（）：Promise{
承诺：承诺[]=[]
for（列表的常量值）{
承诺。推送（新承诺（（解决、拒绝）=>{
const data=等待某事
//处理数据
常量fancyObject={}
解决（fancyObject）；
}));
返回承诺。全部（承诺）；
}

您可以看到，依赖于数据对象的逻辑仅在通过
await
运算符解析承诺后运行。因此，此逻辑需要包装在承诺本身中

Promise.all
本身返回一个Promise，因此您不需要将其包装在另一个Promise中，并解析为包含所有FancyObject的数组。
还要注意，wait语法需要try-catch块，以便在promise解析时捕获发生的错误

我希望我正确地理解了你的意思，你可以从我的例子中吸取一些教训。
这里有几件事不对

首先，您没有将承诺推入
promises
变量，而是将
myMetaMember
变量推入该数组

其次，如果您已经在使用
wait
序列化异步请求，则根本不需要使用
Promise.all（）

第三，当您不需要这样做时，您正在使用几种反模式，将现有承诺包装到手动创建的承诺的附加层中

第四，您通常不希望混合使用
wait
和
。然后（）
和
.catch（）
。要捕获
wait
中的错误，请使用
try/catch
。不需要使用
。然后（）
，因为
wait
已经为您获取了值

第五，
getResolvePromise（）
似乎没有做任何有用的事情。它调用
Promise.all（[target]）
，然后返回一个解析为
target
的承诺。这个承诺似乎没有完成任何有用的事情。您认为它完成了什么

既然你现在已经澄清了