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 導致無法刪除 NaNconst 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); // 原數組不變
// 刪除首個匹配
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)];
}
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"]
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)];
}
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 離屏處理
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]
for...in、與庫衝突filter(o => o !== target) 只能刪除同引用對象,按屬性刪除需用 predicatedelete arr[2] 產生空位,filter 會稀疏轉稠密,for...in 會遍歷索引「刪除數組元素」看似簡單,實則涉及不可變性、語義精確、性能權衡。現代 JS 開發首選 filter 返回新數組,配合 indexOf/findIndex 處理單個刪除,拒絕汙染原型、修改原數組的舊模式。