Question

我有一个main（）函数。这个主要函数调用一些函数，其中一个称为TEST（）。 TEST（）调用TEST1（）。这个TEST1（）调用让我们说TEST2（）。我的问题是TEST2（）创建了一个必须初始化的对象，然后我的main（）调用下一个函数，而TEST（）调用其他任何东西。我这样尝试过，但是不起作用：

function main(){
    TEST1()
    //other functions
}

async function TEST() {
    await TEST1() // TEST1() and TEST2() should finish before 
    //going on with "some code"
    //some code
}

async function TEST1(something) {
    return new Promise(resolve => {
        //some stuff
        let newobject = await TEST2(somethingelse)
        resolve(newobject)
    });
}

function TEST2(somethingelse) {
    return new Promise(resolve => {
        //make object
        resolve(object)
        return object;
    });
}

TEST（）已与TEST1（）一起使用。但是，当将“ asnyc”关键字添加到TEST1（）并添加TEST2（）时，它将不再起作用。可能是因为您可能无法在异步函数中使用Promise？

错误是：

在此上下文中不允许使用“ await”表达式。

Answer 1

无需将newobject包裹在另一个Promise中，您可以像在{{1}中那样直接从TEST2(somethingelse)函数返回TEST1的结果}上下文将返回结果隐式包装在Promise中。

您还需要使async等待，使main函数异步：

在我的main（）调用下一个函数而我的TEST（）调用任何东西之前其他。

main

Answer 2

首选使用async / await语法。更清晰的代码。并抛弃“函数”，更喜欢使用“ const”，因为它可以是一个函数。也更喜欢使用箭头功能。而不是const foo（value）{...}应该是const foo =（value）=> {...}。

const TEST = async () => {
     console.log("Before TEST1");
     await TEST1() 
     //some code
     console.log("Executing some other code");
     console.log("TEST finished");
}

const TEST1 = async (something) {
     console.log("TEST1 started");
     let result = await TEST2('somethingelse');
     console.log("TEST1 finished", result);
     return result;
}

const TEST2 = async (somethingelse) => {
      console.log("TEST2 started");
      const object = {"foo":somethingelse}
      // some async function here... use AWAIT for it.
      return object;

}
const main = async () => {
  await TEST();
}

嵌套的承诺，等待和异步

2 个答案: