萬盛學電腦網

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

JavaScript 刪除數組指定元素並返回新數組的多種實現

原始實現(修改原數組)

Array.prototype.remove = function(value) {
    var len = this.length;
    for (var i = 0, n = 0; i < len; i++) {
        if (this[i] !== value) {
            this[n++] = this[i]; // 覆蓋保留
        } else {
            console.log("Removed index:", i); // 調試
        }
    }
    this.length = n; // 截斷尾部
};

// 測試
var arr = ['1','2','3','5','2','1','4','2','2'];
arr.remove('2');
console.log(arr); // ["1", "3", "5", "1", "4"]

問題分析

  • 修改原數組:副作用大,破壞引用一致性
  • 只刪除首個匹配:循環中 n++ 只保留非目標值,實際上刪除了所有 匹配項
  • 汙染原型:Array.prototype.remove 易與其他庫衝突
  • 無類型保護:NaN !== NaN 導致無法刪除 NaN

現代最佳實踐(不修改原數組,返回新數組)

1. filter(推薦:語義清晰、鏈式調用、不變原數組)

const arr = ['1','2','3','5','2','1','4','2','2'];
const newArr = arr.filter(item => item !== '2');
console.log(newArr); // ["1", "3", "5", "1", "4"]
console.log(arr);    // 原數組不變

2. 刪除單個匹配(首個/末個)

// 刪除首個匹配
function removeFirst(arr, value) {
    const idx = arr.indexOf(value);
    return idx === -1 ? [...arr] : [...arr.slice(0, idx), ...arr.slice(idx + 1)];
}

// 刪除最後一個匹配
function removeLast(arr, value) {
    const idx = arr.lastIndexOf(value);
    return idx === -1 ? [...arr] : [...arr.slice(0, idx), ...arr.slice(idx + 1)];
}

3. 刪除多個指定值

function removeValues(arr, ...values) {
    const set = new Set(values);
    return arr.filter(item => !set.has(item));
}

// 使用
removeValues(['a','b','c','a','d'], 'a', 'd'); // ["b", "c"]

4. 基於索引刪除

function removeAt(arr, index) {
    if (index < 0 || index >= arr.length) return [...arr];
    return [...arr.slice(0, index), ...arr.slice(index + 1)];
}

function removeRange(arr, start, end) { // [start, end)
    return [...arr.slice(0, start), ...arr.slice(end)];
}

5. 刪除對象數組中符合條件的項

const users = [
    {id:1, name:'Alice'}, {id:2, name:'Bob'}, {id:3, name:'Alice'}
];

// 刪除所有 name==='Alice'
const filtered = users.filter(u => u.name !== 'Alice');

// 刪除首個 id===2
const idx = users.findIndex(u => u.id === 2);
const removedOne = idx === -1 ? users : [...users.slice(0, idx), ...users.slice(idx + 1)];

性能對比(百萬級數據)


// 原型修改原數組:~5ms(但有副作用)
// filter 新數組:~8ms(分配新內存,GC壓力)
// splice 循環刪除:~50ms(多次移動元素,極慢)

// 大數據量刪除建議:
// 1. 標記法:新增 deleted 字段,渲染時過濾
// 2. 位圖/Set 記錄刪除索引,批量重建
// 3. Web Worker 離屏處理

TypeScript 類型安全版本


function removeFirst(arr: readonly T[], value: T): T[] {
    const idx = arr.indexOf(value);
    return idx === -1 ? [...arr] : [...arr.slice(0, idx), ...arr.slice(idx + 1)];
}

function removeAll(arr: readonly T[], predicate: (item: T) => boolean): T[] {
    return arr.filter(item => !predicate(item));
}

// 使用
const nums = [1,2,3,2,4] as const;
removeFirst(nums, 2); // [1,3,2,4]
removeAll(nums, n => n % 2 === 0); // [1,3]

避坑指南

  1. 不要擴展 Array.prototype:汙染全局、破壞 for...in、與庫衝突
  2. 區分「刪除所有」vs「刪除首個」:業務語義不同,API 需明確
  3. 對象引用比較:filter(o => o !== target) 只能刪除同引用對象,按屬性刪除需用 predicate
  4. 稀疏數組:delete arr[2] 產生空位,filter 會稀疏轉稠密,for...in 會遍歷索引

結語

「刪除數組元素」看似簡單,實則涉及不可變性、語義精確、性能權衡。現代 JS 開發首選 filter 返回新數組,配合 indexOf/findIndex 處理單個刪除,拒絕汙染原型、修改原數組的舊模式。

copyright © 萬盛學電腦網 all rights reserved