In a nested for loop, is there any advantage in starting with the longer loop? Or vice versa?

Question

For example:

var longArray = [1, 2, 3, 4]
var shortArray = [2, 3]

Which one is faster?

Long loop first:

for (var i = 0; i < longArray.length; i++) {
  for (var j = 0; j < shortArray.length; j++) {
    if (longArray[i] === shortArray[j]) {
      // do something
    }
  }
}

Or short loop first:

for (var i = 0; i < shortArray.length; i++) {
  for (var j = 0; j < longArray.length; j++) {
    if (longArray[i] === shortArray[j]) {
      // do something
    }
  }
}

Or are there any advantages in either that I'm not considering? Or does it not matter at all?

Answer 1

Short loop first is generally faster, only because it spends more time visiting elements in the same order as they tend to be laid out in memory. You need longArray to have a lot more elements, at least several thousand. Here is a test case to demonstrate the difference: https://jsperf.com/loop-order-sl

For the arrays you posted, which has a longArray that is relatively small, there is negligible difference in performance. The shorter array might be a tiny bit faster as @Ajaypayne observed or vice-versa depending on environment.

Answer 2

There is no significant difference between the two. Depending on how you benchmark it you might get a slight speed increase one way or another but it will never amount to much. In the end you will have i*j total iterations. So, how do you make a decision on which way to go?

1. Depending on the specific circumstances you may be able to eliminate certain iterations. @Mark_M hits on this in his comment about the sorting. If you are checking for equality and they are both sorted then you can exit the inner loop as soon as you get a hit. Little things like this can add up to a significant overall gain in particularly long running code. (Not that I would ever run a linear search through sorted arrays but that isn't the point here.)

2. If there is clear way to shorted the looping as described in (1), then shoot for clarity rather than performance. Even if you are only coding for yourself, looking at code you wrote 6-months ago can often be bewildering. Choose which seems more natural or obvious and save yourself (and others) headaches later.