LogWhispererAI/.opencode/skills/frontend-developer/react/rules/js-length-check-first.md

title, impact, impactDescription, tags

title	impact	impactDescription	tags
Early Length Check for Array Comparisons	MEDIUM-HIGH	avoids expensive operations when lengths differ	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):

function 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):

function hasChanges(current: string[], original: string[]) {
  // Early return if lengths differ
  if (current.length !== original.length) {
    return true
  }
  // Only sort/join 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