Question

我试图学习async-await。在这段代码中 -

const myFun = () => {
    let state = false;

    setTimeout(() => {state = true}, 2000);

    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if(state) {
                resolve('State is true');
            } else {
                reject('State is false');
            }
        }, 3000);
    });
}

const getResult = async () => {
    return await myFun();
}

console.log(getResult());

为什么我得到输出 -

Promise { <pending> }

而不是一些价值？ getResult()函数是否应该等待myFun()函数解析它的承诺值？

Answer 1

如果您正在使用async / await，则所有调用都必须使用Promises或async / await。你不能只是神奇地从同步调用中获得异步结果。

您的最终通话需要是：

innerrecyclerview

或类似的东西：

getResult().then(response => console.log(response));

Answer 2

在实际情况下，没有必要进行异步和等待：

    Script compilation errors:

  Line 01: import io.gitlab.arturbosch.detekt.Detekt
                  ^ Unresolved reference: io

  Line 10:  val detekt by existing(Detekt::class) {
                                   ^ Unresolved reference: Detekt

  Line 11:      reports {
             ^ Unresolved reference: reports

  Line 12:          html {
              ^ Unresolved reference: html

换句话说，由于then（）的分叉和运行速度比后续语句慢（即使对于已解决的Promise而言），因此我们需要将后续语句放入then语句中，例如：

Promise.resolve(3).then(console.log); console.log(4);
4
3

既然这是真的，那为什么还要费心等待。所以我还没有看到为什么异步和等待甚至存在。

Answer 3

这是我的日常工作，使用带有解决和拒绝的承诺来处理等待和异步 机制

    // step 1 create a promise inside a function
    function longwork()
    {
        p =  new Promise(function (resolve, reject) {
            result = 1111111111111 // long work here ; 

            if(result == "good"){
                resolve(result);
            }
            else
            {
                reject("error ...etc")
            } 
        })

        return p
    }

    // step 2 call that function inside an async function (I call it main)and use await before it
    async function main()
    {
         final_result = await longwork();
         //..

    }  

    //step 3 call the async function that calls the long work function
    main().catch((error)=>{console.log(error);})

希望为某人节省宝贵的时间

Answer 4

您需要了解的是async / await不会使您的代码同步运行，但让您像这样编写它：

简而言之：前面带有async的函数实际上是异步执行的，因此是关键字“ async”。而“ await”关键字将使在此异步函数中使用它的行在执行过程中等待promise。因此，尽管该行等待，但整个函数仍将异步运行，除非该函数的调用者也“唤醒”了...

更详细地解释：当您将异步放在函数的前面时，实际上所做的是使它返回一个带有函数内部返回值的承诺。该函数异步运行，当执行return语句时，promise解析返回值。

含义，在您的代码中：

const getResult = async () => {
    return await myFun();
}

函数“ getResult（）”将返回一个Promise，该Promise将在执行完毕后解析。因此，除非您告诉调用getResult（）的函数也要对其“等待”，否则getResult（）函数内的各行将异步运行。在getResult（）函数内部，您可能会说它必须等待结果，这会使getResult（）的执行等待其解决承诺，但是getResult（）的调用者不会等待，除非您还告诉调用者'await '。

因此，解决方案将调用以下任一方法：

getResult().then(result=>{console.log(result)})

或者在其他功能中使用时，只需再次使用'await'

async callingFunction(){
    console.log(await(getResult());
}

异步功能 - 等待不等待承诺

4 个答案: