Javascript return statement doesn't stop rest of function from completing-CodePudding

I am using Docuware's API to staple (merge) documents together. I have written my question as simple as I can so people with no Docuware knowledge should be able to understand.

So in my main function, I call another function and check the return value of the called function. If the value equals zero, it should return null - meaning the rest of the function should not run.

const lastStored = await searchDocument("Invoice", ORDER_NUMBER = '', cookie)
console.log("Full id func: "   id)
console.log("id[0]: "   id[0])

if (lastStored[0] === 0) {
    console.log("id[0]: "   id[0])
    return null;
};

I am getting weird errors with my code, so I have a lot of console.logs. Here are the console.logs when the code successfully works.

 cookie set
 Document is Invoice (Invoice)
 Invoice order #: ORD83001
 Current ID: 52724 Order #: ORD83001
 cookie set
 Document is DELIVERY SLIP (DELIVERY SLIP)
 Invoice order #: ORD83001
 DELIVERY SLIP Doc ID: 52553
 Current ID: 52553 Order #: ORD83001
 Full id func: 52553,ORD83001
 id[0]: 52553
 New Tray Doc ID: 1410
 Document's successfully merged.

Now, with the error, the console.logs are:

 //.....
 Current ID: 0 Order #: ORD83009
 Full id func: 0,ORD83009
 id[0]: 0
 id[0]: 0
 Document's successfully merged.

The thing about this error, is that if id[0] was truly zero, then the document's wouldn't be able to be merged. But the documents ARE merged if I look at them. So why is my code returning 0, even INSIDE my if statement, yet continues to run?

Is it some sort of timing issue? Like id[0] === 0 but .00000001 seconds later it gets updated so the return null doesn't follow through?

CodePudding user response：

This happens because you have await between the part of the code where you return null and where the output of "Document's successfully merged" is made.

Every await is a point in your code where an execution context is suspended. Depending on the awaited promise, there will be some time in the future where the suspended execution will be resumed again. This can lead to surprising sequences of output.

Here is a simple demo of this effect. Note how the output in the if block is followed by the output below it. It would be wrong to conclude that the return somehow didn't "work". It did, but there was another execution of this function which was suspended (as waiting for a promise to resolve) and got restored only to make that final output:

const something = i => new Promise(resolve => setTimeout(resolve, i * 1000));

async function demo(i) {
    console.log("test the value of i");
    if (i == 1) {
        console.log("i is one, so we exit");
        return null;
    }
    await something(i);
    console.log("performed the action");
}

demo(0);
demo(1);