JS：不确定何时使用 Promise.resolve() 与返回新的 Promise

Question

I am unsure how the usage of returning a new Promise vs using a Promise.resolve() and want to make sure my understanding of these are correct.

Given these 3 functions below:

    function testFunc() {
          return Promise.resolve().then(() => {
             //anything asynchronous in here has now become synchronous and 
             //execution of result of the function happens after this??
              let i = 0;
              while (i < 10000) {
                 console.log(i);
                 i++;
              }
          });
    }
------
    function testFunc2() {
          return new Promise((resolve, reject) => {
               //anything asynchronous in here is still asynchronous but the 
               //`resolve()` is then synchronous?? 
               let i = 0;
                while (i < 10000) {
                  if (i === 999) { resolve('I am a test func') };
                  i++;
                }
          })
    }
------

    //synchronous function 
    
    function logMe() {
         let i = 0;
         while (i < 10000) {
            console.log("INSIDE LOG ME);
            i++;
         }
    }

The way I understand it is that testFunc() immediately resolves the Promise and anything within there becomes synchronous. So if you were to execute:

testFunc();
logMe();

testFunc() would fully execute before logMe() was reached and executed.

For the testFunc2() , if it were executed in this order:

   testFunc2();
   logMe();

I understand it as the logic inside, in this case the while loop, would still execute synchronously and delay the execution of the following function, logMe() , but the resolve would be treated asynchronously.

Answer 1

It's not that easy. You would have to use test Func.then(logMe()) . Another option would be to run both functions in an asynchronous function:

async function run() {
  await testFunc();
  logMe();
}

The await is pretty simple - it runs the function and waits for it to finish, then runs the next lines. async is just there so that await can work (await does not work outside of async functions).

I prefer async / await , but many more prefer .then . It's just what you want to use, both are very similar.

Answer 2

If I understand correctly what you're trying to achieve, you want to asynchronously execute operation inside the loop.

function testFunc2() {
  const promises = []
  for(let i = 0; i<1000; i++){
       promises.push(new Promise((resolve) => {
         console.log(i);
         resolve()
       }));
     }
  return Promise.all(promises);
}

function logMe() {
  let i = 0;
  while (i < 5) {
     console.log("INSIDE LOG ME");
     i++;
  }
}

(async() => {
  await testFunc2()
  logMe();
})();