early-length-check-for-array-comparisons

---

name: Early Length Check for Array Comparisons impact: MEDIUM-HIGH description: avoids expensive operations when lengths differ tags: javascript, arrays, performance, optimization, comparison

Early Length Check for Array Comparisons

When comparing arrays with expensive operations (sorting, deep equality, serialization), check lengths first. If lengths differ, the arrays cannot be equal.

In real-world applications, this optimization is especially valuable when the comparison runs in hot paths (event handlers, render loops).

Incorrect (always runs expensive comparison):

Copyfunction hasChanges(current: string[], original: string[]) {
  // Always sorts and joins, even when lengths differ
  return current.sort().join() !== original.sort().join()
}

Two O(n log n) sorts run even when current.length is 5 and original.length is 100. There is also overhead of joining the arrays and comparing the strings.

Correct (O(1) length check first):

Copyfunction hasChanges(current: string[], original: string[]) {
  // Early return if lengths differ
  if (current.length !== original.length) {
    return true
  }
  // Only sort when lengths match
  const currentSorted = current.toSorted()
  const originalSorted = original.toSorted()
  for (let i = 0; i < currentSorted.length; i++) {
    if (currentSorted[i] !== originalSorted[i]) {
      return true
    }
  }
  return false
}

This new approach is more efficient because:

• It avoids the overhead of sorting and joining the arrays when lengths differ
• It avoids consuming memory for the joined strings (especially important for large arrays)
• It avoids mutating the original arrays
• It returns early when a difference is found