Is it more performant to use several for-loops by themself or to delegated the logic to promises?

Question

Following scenario: A function gets 3 arrays of a certain length, each one of those needs to be iterated over to find a matching object. When the object is found, the for-loop breaks and the next one isn't called. The arrays can't be merged in this case. Basically like this:

for (let i = 0; i < array1.length; i++) {
  if (array1[i].id == matchingID) {
    returnValue = array1[i];
    break;
  }
}
if (!returnValue) {
  for (let i = 0; i < array2.length; i++) {
    if (array2[i].id == matchingID) {
      returnValue = array2[i];
      break;
    }
  }
}
if (!returnValue) {
  for (let i = 0; i < array3.length; i++) {
    if (array3[i].id == matchingID) {
      returnValue = array3[i];
      break;
    }
  }
}
return returnValue;

Would using promises be more efficient in this case, since that way all for-loops can be worked at at the same time? Like this, with each function-call doing one of the for-loops (and resolving the found value) from the example above:

return new Promise((resolve) => {
  this.findMatchingIDInArray1(array1)
    .then(() => resolve(returnValue));
  this.findMatchingIDInArray2(array2)
    .then(() => resolve(returnValue));
  this.findMatchingIDInArray3(array3)
    .then(() => resolve(returnValue));
}) 

Which way is more perfomant? Is there better way to do this? Thanks for your help!

Answer 1

Would using promises be more efficient in this case, since that way all for-loops can be worked at at the same time?

No, you misunderstood what promises do. They're a tool to make dealing with asynchronous code easier. There is no asynchronous code in your use case, so you cannot make use of promises here. Promises do not "make" anything asynchronous, or even enable multithreading-like parallelism.

Answer 2

Would using promises be more efficient in this case, since that way all for-loops can be worked at at the same time?

No, because promises don't make anything asynchronous or parallel. They can only be used to observe things that are already asynchronous or parallel.

All that throwing promises at that code would do is change when the main thread blocks and add overhead.

If you need to offload or parallelize long-running computational tasks, look at web workers .

Answer 3

The code would not be any more performant.

JavaScript is typically single-threaded (unless you use web workers ), so your code wouldn't complete any more quickly using promises (because the loops wouldn't run in parallel)—in fact, if anything, it might be imperceptibly slower.

A promise is more of a way to handle the outcome of asynchronous code, and not a way to cause code to run asynchronously.