AngeloooooandDraculabo
8ed4593f73
* Refactor Gemini model display: filter old versions, group low/high pro, and improve naming * Fix potential negative minutes and refine Gemini 3 Pro grouping logic based on PR feedback * The account change process has been sped up * Address PR review: enhance error message and parameterize polling interval in process handler * Address PR review: fix potential race condition in database backup logic * fix: prevent renderer white screen and harden sentry gating * feat: localize model labels * chore: enable hoisted node-linker * chore: ignore .agent/.claude/.codex in prettier --------- Co-authored-by: Draculabo <[email protected]>
51 lines
1.7 KiB
Markdown
51 lines
1.7 KiB
Markdown
---
|
|
title: Early Length Check for Array Comparisons
|
|
impact: MEDIUM-HIGH
|
|
impactDescription: 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):**
|
|
|
|
```typescript
|
|
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):**
|
|
|
|
```typescript
|
|
function 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
|