陣列去重是高頻需求。資料類型越複雜(物件、函式、NaN、Symbol),去重難度越高。本文從簡單到完整,分析三種主流演算法的原理、代碼、效能與適用場景。
function unique1(arr) {
const res = [];
for (let i = 0; i < arr.length; i++) {
let repeat = false;
for (let j = 0; j < res.length; j++) {
if (arr[i] === res[j]) { repeat = true; break; }
}
if (!repeat) res.push(arr[i]);
}
return res;
}
function unique2(arr) {
const sorted = [...arr].sort((a, b) => {
if (a === b) return 0;
// 簡易跨類型排序:數字 < 字串 < 物件
return typeof a < typeof b ? -1 : 1;
});
const res = [sorted[0]];
for (let i = 1; i < sorted.length; i++) {
if (sorted[i] !== sorted[i-1]) res.push(sorted[i]);
}
return res;
}
1` vs `"1"`(排序後相鄰但 `==` 為 true)function unique3(arr) {
return [...new Set(arr)];
}
⚠️ `Set` 以 **SameValueZero** 比較:NaN === NaN 為 true、+0 === -0 為 true、物件比較**參考位址**。
function uniqueWithType(arr) {
const seen = new Map(); // 或 Object.create(null)
return arr.filter(item => {
const key = typeof item + ":" + (item === null ? "null" :
typeof item === "object" ? JSON.stringify(item) : item);
if (seen.has(key)) return false;
seen.set(key, true);
return true;
});
}
⚠️ `JSON.stringify` 無法處理函式、循環引用、Symbol、不可序列化物件。
function isEqual(a, b) {
if (a === b) return true; // 含 NaN 檢查需額外處理
if (typeof a !== typeof b) return false;
if (typeof a !== "object" || a === null || b === null) return a === b;
if (Array.isArray(a) !== Array.isArray(b)) return false;
const keysA = Object.keys(a), keysB = Object.keys(b);
if (keysA.length !== keysB.length) return false;
return keysA.every(k => isEqual(a[k], b[k]));
}
function uniqueDeep(arr) {
const res = [];
for (const item of arr) {
if (!res.some(existing => isEqual(existing, item))) {
res.push(item);
}
}
return res;
}
// 測試
uniqueDeep([{a:1}, {a:1}, {a:1,b:2}, f, f]);
// [{a:1}, {a:1,b:2}, f] (f 為同函式參考)
| 方法 | 耗時 (ms) | 記憶體 | 備註 |
|---|---|---|---|
| Set | ~8 | 低 | 最快、最推薦 |
| Map + typeof key | ~15 | 低 | 區分型別 |
| filter + indexOf | ~1200 | 低 | O(n²) 邊界 |
| 雙層迴圈 | ~2500 | 低 | 最慢 |
| 深度比較 | ~5000+ | 高 | 僅複雜物件必要 |
資料類型?
├─ 純基本型別 (number/string/boolean/null/undefined) → [...new Set(arr)]
├─ 需區分 1 vs "1" → Map/Object + typeof 前綴鍵
├─ 物件/陣列需「內容相等」去重 → 深度比較 (小資料) / 正規化序列化 (大資料)
└─ 函式/ Symbol / 循環引用 → 深度比較或自定義序列化
// 90% 場景:基本型別去重 + 保持順序
const unique = [...new Set(arr)];
// 需區分型別
function uniqueTyped(arr) {
const seen = new Set();
return arr.filter(x => {
const key = typeof x + "#" + x;
return seen.has(key) ? false : seen.add(key);
});
}
**首選 `Set`(ES6+)**,效能最佳、代碼最少。需區分型別加前綴鍵。複雜物件內容去重才考慮深度比較,並評估效能成本。不要盲目追求「完美通用」,根據資料特徵選擇最適演算法。