Promise test

promises.js

function fnThatReturnsPromiseOrValue() {
  const random = Math.random();
  if (random > 0.5) {
    return Promise.resolve(random);
  } else {
    return random;
  }
}

async function naive() {
  let total = 0;
  for (let i = 0; i < 1000_000; i++) {
    total += await fnThatReturnsPromiseOrValue();
  }

  console.log(total);
}

async function testFirst() {
  let total = 0;
  for (let i = 0; i < 1000_000; i++) {
    let result = fnThatReturnsPromiseOrValue();
    if (result instanceof Promise) {
      result = await result;
    }
    total += result;
  }

  console.log(total);
}

console.time("naive");
await naive();
console.timeEnd("naive");

console.time("testFirst");
await testFirst();
console.timeEnd("testFirst");

Hey @cyco130.
Saw your post on Twitter which led me to this code.

I was wondering what would happen if we create an array of promises and await them all using Promise.all(). We would have to sacrifice the memory to store the promise and results in an array.

Example:

async function testPromiseAll() {
  let total = 0;
  let promises = [];
  for (let i = 0; i < 1000_000; i++) {
    promises.push(fnThatReturnsPromiseOrValue());
  }

  const results = await Promise.all(promises);
  for(let i = 0; i < results.length; i++){
      total += results[i];
  }

  console.log(total);
}

This gives me better results than the testFirst function.

Hi @jainmohit2001!

Sure, running all promises in parallel would indeed be faster and is the better idea for this particular example.

What I was trying to point out the difference between just awaiting and checking first to see if it's a promise and only awaiting if it is. Doing it a million times was only to multiply the effect to have meaningful numbers :)