異步/等待承諾邏輯問題

Question

我正在學習如何將 async/await 與 Promise 結合使用。 我對第一個承諾有一些問題。 具體來說：

var pres = mvc.Components.get("search1");
pres.data('results', {
  count: 0,
  output_mode: 'json_rows'
}).on("data", function(results) {
  alldata3 = results._data;
  console.log(alldata3)
});    

我正在從另一個腳本中的函數中提取結果。 'search1' 的結果非常大。 例如，它需要更長的時間然后搜索兩個。 我遇到的問題是，它不會等到“results._data”完全分配給 alldata3 后才轉到 itVolTwo()。 這最終給我一個異步錯誤，指示“alldata3.rows”未定義。 無論如何要重新設計它，以便它等到它從search1接收到完整結果？ 這里最好的做法是什么？ 謝謝你的幫助！

var alldata3 = new Object();
var alldata32 = new Object();
// Promise
const itVolOne = new Promise(
  (resolve, reject) => {
    if (boolpool) {
      var pres = mvc.Components.get("search1");
      pres.data('results', {
        count: 0,
        output_mode: 'json_rows'
      }).on("data", function(results) {
        alldata3 = results._data;
        console.log(alldata3)
      });
      console.log(alldata3)
      var rdbms1 = mvc.Components.get("search2");
      rdbms1.data('results', {
        count: 0,
        output_mode: 'json_rows'
      }).on("data", function(results) {
        alldata32 = results._data;
        console.log(alldata32)
      });
      console.log(alldata32)

      console.log(alldata3, alldata32)
      resolve(alldata3, alldata32)
    } else {
      const reason = new Error('Unable to get the datas');
      reject(reason);
    }
  }
);

var rdbmsData = new Object();
async function itVolTwo() {
  return new Promise(
    (resolve, reject) => {
      for await (let row of alldata3.rows) {
        rdbmsData[row[0]] = {
          "crit": row[1],
          "high": row[2],
          "med": row[3],
          "low": row[4]
        }
      }
      console.log(rdbmsData)
      resolve(rdbmsData);
    }
  );
};

// 2nd promise
var presData = new Object();
async function itVolThree() {
  return new Promise(
    (resolve, reject) => {
      for await (let row of alldata32.rows) {
        presData[row[0]] = {
          "crit": row[1],
          "high": row[2],
          "med": row[3],
          "low": row[4]
        }
      }
      console.log(presData)
      resolve(presData);
    }
  );
};
// 3rd promise
var endData = new Object();
async function itVolFour() {
  return new Promise(
    (resolve, reject) => {
      function sum(a, b) {
        Object.keys(b).forEach(k => {
          if (b[k] && typeof b[k] === 'object') return sum(a[k] = a[k] || {}, b[k]);
          a[k] = (+a[k] || 0) + +b[k];
        });
        return a;
      }
      endData = [rdbmsData, presData].reduce(sum);
      console.log(endData)
      resolve(endData);
    }
  );
};
// call our promise
async function itInit() {
  try {
    console.log('I got to the call YEY!');

    let stepOne = await itVolOne;
    let stepTwo = await itVolTwo();
    let stepThree = await itVolThree();
    let stepFour = await itVolFour();

    console.log(endData);
    console.log('Done');
  } catch (error) {
    console.log('u done f'
      ed up ');
    }
  }

  (async() => {
    await itInit();
  })();

Answer 1

您應該“承諾”事件發射器對象（something.data.on），然后您可以等待結果：

  const itVolOne = async () => {
    if (boolpool) {
        const pres = mvc.Components.get("search1");
        const alldata3 = await new Promise(resolve => {
             pres.data('results', {count: 0, output_mode: 'json_rows'}).on("data",
               results => {
                   resolve(results._data);
               }
             );
        });
        console.log(JSON.stringify(alldata3));

        const rdbms1 = mvc.Components.get("search2");
        const alldata32 = await new Promise(resolve => {
           rdbms1.data('results', {count: 0, output_mode: 'json_rows'}).on("data",
             results => {
                resolve(results._data);
             }
           );
        });

        console.log(JSON.stringify(alldata32));

        return { alldata3, alldata32 }
    } else {
       throw new Error('Unable to get the datas');
    }
  }

因此，現在 itVolOne 函數以“同步方式”返回所有結果，其余函數可以重寫：

  const itVolTwo =  alldata3 => {
      return alldata3.rows.reduce((rdbmsData, row) => {
          rdbmsData[row[0]] = {
            "crit": row[1],
            "high": row[2],
            "med":  row[3], 
            "low":  row[4]
          };

          return rdbmsData;
      }, {});
  }

  const itVolThree = alldata32 => {
     return alldata32.rows.reduce((presData, row) => {
          presData[row[0]] = {
             "crit": row[1],
             "high": row[2],
             "med":  row[3], 
             "low":  row[4]
          };
          return presData;
     }, {});
  }

  const itVolFour = (rdbmsData, presData) => {
     function sum(a, b) {
        Object.keys(b).forEach(k => {
            if (b[k] && typeof b[k] === 'object') return sum(a[k] = a[k] || {}, b[k]);
            a[k] = (+a[k] || 0) + +b[k];
        });
        return a;
      }
      return [rdbmsData, presData].reduce(sum);
  }

現在您只能在第一步中等待：

  async function itInit() {
    try {
        console.log('I got to the call YEY!');

        const { alldata3, alldata32 } = await itVolOne();
        const stepTwo = itVolTwo(alldata3);
        const stepThree = itVolThree(alldata32);
        const endData = itVolFour(stepTwo, stepThree);

        console.log(JSON.stringify(endData));
        console.log('Done');
    }
    catch (error) {
        console.log('u done f\'ed up');
    }
  }

並調用主函數：

itInit();

就這樣。