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!

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!

• javascript
• performance
• typescript
• ecmascript-6
• promise

Share Improve this question Follow edited Sep 22, 2018 at 18:12 loganfsmyth 162k3131 gold badges346346 silver badges258258 bronze badges asked Sep 21, 2018 at 13:31 TobiDevloftTobiDevloft 30133 silver badges1212 bronze badges 7

• 5 There's no reason to use promises because nothing in your function is asynchronous. – Pointy Commented Sep 21, 2018 at 13:32
• 2 Promises are doing nothing here as you have no async code. – Liam Commented Sep 21, 2018 at 13:32
• 1 You meant to use array…[i].id, right? – Bergi Commented Sep 21, 2018 at 13:38
• 3 You are performing linear search for O(n) in each for loop. If you're not changing your algorithm, you're not going to change that performance. If the arrays are sorted, then you can execute a binary search which will be faster. Then again, if the arrays don't have a lot of items, I don't think it would really matter that much. If you do have enormous amounts of data in each array, then a sort followed by a search optimised for sorted data could still give you a net performance boost. However, all that requires on data - don't do premature optimisation without testing first. – VLAZ Commented Sep 21, 2018 at 13:44
• @Bergi yes, this is just an example that I wrote down really quick. Fixed! – TobiDevloft Commented Sep 21, 2018 at 13:48

 |  Show 2 more ments

3 Answers 3

Sorted by: Reset to default 8

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.

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 putational tasks, look at web workers.

The code would not be any more performant.

JavaScript is typically single-threaded (unless you use web workers), so your code wouldn't plete 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 oute of asynchronous code, and not a way to cause code to run asynchronously.