萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 腳本程式專題 >> JavaScript

JavaScript 陣列去重完整指南:三種演算法效能與適用場景深度解析

前言

陣列去重是高頻需求。資料類型越複雜(物件、函式、NaN、Symbol),去重難度越高。本文從簡單到完整,分析三種主流演算法的原理、代碼、效能與適用場景。

方法一:雙層迴圈(O(n²))

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;
}
  • ✅ 保持原順序
  • ✅ 支援所有類型(含 NaN、物件參考比較)
  • ❌ O(n²) 效能差,大陣列不可用

方法二:排序後相鄰比較(O(n log n))

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)
  • ❌ 物件/函式無法直接比較

方法三:Hash Map / Set(O(n))—— 推薦

3.1 ES6 Set(最簡潔,支援基本型別 + 物件參考)

function unique3(arr) {
  return [...new Set(arr)];
}

⚠️ `Set` 以 **SameValueZero** 比較:NaN === NaN 為 true、+0 === -0 為 true、物件比較**參考位址**。

3.2 物件鍵值法(支援型別區分:1 vs "1")

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、不可序列化物件。

3.3 通用深度比較版(處理物件/函式內容相等)

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 為同函式參考)
  • ✅ 內容語意去重
  • ❌ O(n²) 效能差、遞迴深度限制、函式比較僅能比較 `toString()`

效能基準測試參考(10 萬筆隨機數字)

方法耗時 (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+)**,效能最佳、代碼最少。需區分型別加前綴鍵。複雜物件內容去重才考慮深度比較,並評估效能成本。不要盲目追求「完美通用」,根據資料特徵選擇最適演算法。

copyright © 萬盛學電腦網 all rights reserved