Cursor rule

1---
2alwaysApply: false
3---
4 
5## Early Length Check for Array Comparisons
6 
7When comparing arrays with expensive operations (sorting, deep equality, serialization), check lengths first. If lengths differ, the arrays cannot be equal.
8 
9In real-world applications, this optimization is especially valuable when the comparison runs in hot paths (event handlers, render loops).
10 
11**Incorrect (always runs expensive comparison):**
12 
13```typescript
14function hasChanges(current: string[], original: string[]) {
15  // Always sorts and joins, even when lengths differ
16  return current.sort().join() !== original.sort().join()
17}
18```
19 
20Two 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.
21 
22**Correct (O(1) length check first):**
23 
24```typescript
25function hasChanges(current: string[], original: string[]) {
26  // Early return if lengths differ
27  if (current.length !== original.length) {
28    return true
29  }
30  // Only sort when lengths match
31  const currentSorted = current.toSorted()
32  const originalSorted = original.toSorted()
33  for (let i = 0; i < currentSorted.length; i++) {
34    if (currentSorted[i] !== originalSorted[i]) {
35      return true
36    }
37  }
38  return false
39}
40```
41 
42This new approach is more efficient because:
43- It avoids the overhead of sorting and joining the arrays when lengths differ
44- It avoids consuming memory for the joined strings (especially important for large arrays)
45- It avoids mutating the original arrays
46- It returns early when a difference is found
47