Dynamic Promise?

[pikadun]

async function asyncFn() {
    if (<condition>) {
        return 1;
    } else {
        return new Promise((resolve) => {
            resolve(0);
        });
    }
}

When the function is called, a Promise is generated, it's very simple and clear.

But if this function is called multiple times (for example, 1 million times), and in most cases it will hit the if statement, it will produce a lot of unnecessary performance loss.

I have to do like this:

let tmp = asyncFn();
if (typeof tmp.then === 'function') {
    tmp = await tmp;
}

I think it can return a base type instead of Promise , we also don’t need to use await to get the result.

It can return Promise when the return type is really Promise.

Should the interpreter optimize the code?

[buyan302]

Why not extract the if statement outside asyncFn ? It's a good pattern to keep function return the same type.

function syncFn() {
  return 1
}
async function asyncFn() {
    return new Promise((resolve) => {
     resolve(0);
   });
}



if(condition){
  syncFn()
} else {
  await asyncFn()
}