萬盛學電腦網

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

JavaScript 陣列去重完全指南:7 種經典算法效能對比與現代最佳實踐

前言

陣列去重是前端面試高頻題,也是實務開發常見需求。本文整理 7 種主流去重方法,從 ES5 到 ES6+,分析時間/空間複雜度、型別支援度、順序保留特性,助你根據場景選擇最優方案。

方法一:雙層迴圈 + indexOf(ES5 基礎)

function unique1(arr) {
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    if (result.indexOf(arr[i]) === -1) result.push(arr[i]);
  }
  return result;
}
  • 時間複雜度:O(n²)
  • 空間複雜度:O(n)
  • 保留首次出現順序
  • 支援所有型別(物件以引用比較)

方法二:物件鍵值去重(哈希表)

function unique2(arr) {
  const seen = {};
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    const key = typeof arr[i] + ':' + JSON.stringify(arr[i]); // 簡易序列化區分型別
    if (!seen[key]) {
      seen[key] = true;
      result.push(arr[i]);
    }
  }
  return result;
}
  • 時間複雜度:O(n)
  • 需序列化處理物件/陣列,效能開銷較大
  • 無法區分 1 與 '1'(除非加型別前綴)

方法三:鍵值互換法(巧用物件特性)

function unique3(arr) {
  const obj = {};
  for (const val of arr) obj[val] = 1;
  return Object.keys(obj).map(key => {
    // 嘗試還原型別:數字、布林、null、undefined 需特殊處理
    if (key === 'true') return true;
    if (key === 'false') return false;
    if (key === 'null') return null;
    if (key === 'undefined') return undefined;
    return isNaN(key) ? key : Number(key);
  });
}
  • 極簡代碼,但型別還原易出錯(如 {a:1} 變成 '[object Object]')
  • 不保留順序(ES2015+ 保留插入順序,但為實作細節)
  • 僅適用於基本型別陣列

方法四:排序後相鄰比較

function unique4(arr) {
  const sorted = [...arr].sort((a, b) => {
    if (a === b) return 0;
    return a < b ? -1 : 1; // 簡易比較,混合型別可能報錯
  });
  return sorted.filter((val, i) => i === 0 || val !== sorted[i-1]);
}
  • 時間複雜度:O(n log n)
  • 不保留原順序
  • 排序比較函數需處理混合型別

方法五:ES6 Set(現代標準,推薦)

const unique5 = arr => [...new Set(arr)];
// 或
function unique5(arr) {
  return Array.from(new Set(arr));
}
  • 時間複雜度:O(n)
  • 空間複雜度:O(n)
  • 完美保留首次出現順序
  • 原生支援所有型別(物件以引用比較)
  • 代碼最簡潔、可讀性最高

方法六:Map 進階去重(支援自定義比較鍵)

function uniqueByKey(arr, keyFn = x => x) {
  const map = new Map();
  for (const item of arr) {
    const key = keyFn(item);
    if (!map.has(key)) map.set(key, item);
  }
  return [...map.values()];
}

// 例:物件陣列按 id 去重
const users = [{id:1, name:'A'}, {id:2, name:'B'}, {id:1, name:'A2'}];
console.log(uniqueByKey(users, u => u.id)); // [{id:1, name:'A'}, {id:2, name:'B'}]

方法七:reduce + Set/Map(函數式風格)

const unique7 = arr => arr.reduce((acc, cur) => {
  if (!acc.set.has(cur)) {
    acc.set.add(cur);
    acc.arr.push(cur);
  }
  return acc;
}, {set: new Set(), arr: []}).arr;

效能基準測試(參考:陣列長度 10,000,基本型別)

方法耗時 (ms)備註
Set (ES6)~2最快、最推薦
Map~3功能最強
Object 鍵值~5需序列化開銷
indexOf 雙層迴圈~150O(n²) 明顯慢
排序法~15排序開銷大

物件/陣列去重深層比較

若需按內容比較物件(深度去重),需序列化或使用 JSON.stringify 作為鍵:

function deepUnique(arr) {
  const seen = new Set();
  return arr.filter(item => {
    const key = JSON.stringify(item); // 注意:鍵順序不同會視為不同
    if (seen.has(key)) return false;
    seen.add(key);
    return true;
  });
}

更健壯的深度比較建議使用 Lodash _.uniqWith 搭配 _.isEqual。

最佳實踐建議

  1. 基本型別陣列:直接用 [...new Set(arr)]。
  2. 物件陣列按特定欄位去重:使用 Map 或 uniqueByKey。
  3. 深度內容去重:JSON.stringify 簡單場景,複雜場景用 Lodash。
  4. 超大陣列(百萬級):考慮 Web Worker 離主執行緒處理,或分批處理避免阻塞 UI。
  5. 舊環境相容:引入 core-js polyfill 或使用方法一/二。

總結

ES6 Set 是現代 JavaScript 陣列去重的標準解法,兼具效能、可讀性與正確性。理解各算法原理與適用邊界,能在面試與實戰中遊刃有餘。遇到複雜去重需求時,善用 Map 自定義鍵或成熟工具庫,避免重複造輪子。

copyright © 萬盛學電腦網 all rights reserved