1個
2
3
4
下一個
使用indexOf查找要刪除的數組元素的索引，然後使用splice刪除該索引。
splice（）方法通過刪除來更改數組的內容
現有元素和/或添加新元素。
const array = [2，5，9];
console.log（array）;
const index = array.indexOf（5）;
如果（索引> -1）{
array.splice（index，1）;
}
//數組= [2，9]
console.log（array）;
拼接的第二個參數是要刪除的元素數。請注意，splice修改了該數組並返回一個包含已刪除元素的新數組。
出於完整性的原因，這裡有一些功能。第一個函數僅刪除一個匹配項（即從[2,5,9,1,5,8,5]中刪除第一個匹配項5），而第二個函數則刪除所有匹配項：
函數removeItemOnce（arr，value）{
var index = arr.indexOf（value）;
如果（索引> -1）{
arr.splice（index，1）;
}
返回arr;
}
函數removeItemAll（arr，value）{
var i = 0;
而（i = 0; i--）{
如果（array [i] ===數字）{
array.splice（i，1）;
}
}
如果您只想使索引i處的元素不再存在，但又不想更改其他元素的索引：
刪除數組[i];
|
於2016年10月編輯
做到簡單，直觀和明確（Occam的剃刀）
做到一成不變（原始數組保持不變）
如果您的瀏覽器不支持標準JavaScript函數，請執行此操作-使用polyfill
在此代碼示例中，我使用“ array.filter（...）”函數從數組中刪除不需要的項。此函數不會更改原始數組，而是創建一個新數組。如果您的瀏覽器不支持此功能（例如，版本9之前的Internet Explorer或版本1.5之前的Firefox），請考慮使用Mozilla中的過濾器polyfill。
刪除項目（ECMA-262版本5代碼又稱為舊式JavaScript）
變量值= 3
var arr = [1、2、3、4、5、3]
arr = arr.filter（function（item）{
返回項目！==值
}）
console.log（arr）
// [1，2，4，5]
刪除項目（ECMAScript 6代碼）
令值= 3
令arr = [1、2、3、4、5、3]
arr = arr.filter（item =>項目！==值）
console.log（arr）
// [1，2，4，5]
重要信息ECMAScript 6的（（）=> {}“箭頭函數語法在Internet Explorer，45之前的Chrome，22之前的Firefox和10之前的Safari中完全不受支持。要在舊版瀏覽器中使用ECMAScript 6語法，可以使用BabelJS。
刪除多個項目（ECMAScript 7代碼）
此方法的另一個優點是您可以刪除多個項目
讓forDeletion = [2，3，5]
令arr = [1、2、3、4、5、3]
arr = arr.filter（item =>！forDeletion.includes（item））
// !!!在下面閱讀有關array.includes（...）的支持！！！
console.log（arr）
// [1，4]
重要信息``array.includes（...）''功能完全不受Internet Explorer，47之前的Chrome，43之前的Firefox，9之前的Safari和14之前的Edge的支持，因此這是Mozilla的polyfill。
刪除多個項目（將來可能）
如果“此綁定語法”提議曾經被接受，則可以執行以下操作：
// array-lib.js
導出函數remove（... forDeletion）{
返回this.filter（item =>！forDeletion.includes（item））
}
// main.js
從'./array-lib.js'導入{刪除}
設arr = [1、2、3、4、5、3]
// ::此綁定語法建議
//將“刪除”功能用作“虛擬方法”
//不擴展Array.prototype
arr = arr :: remove（2，3，5）
console.log（arr）
// [1，4]
在BabelJS中自己嘗試：)
參考
Array.prototype.includes
功能組成
|
這取決於您是否要保留空白位置。
如果您確實想要一個空插槽：
array [index] =未定義；
如果您不想留空的插槽：
//保留原始內容：
// oldArray = [... array];
//這將修改數組。
array.splice（index，1）;
而且，如果您需要該項目的值，則可以只存儲返回的數組的元素：
var值= array.splice（index，1）[0];
如果要刪除數組的任一端，則可以對最後一個數組使用array.pop（）或對第一個數組使用array.shift（）（也都返回該項的值）。
如果您不知道該項目的索引，則可以使用array.indexOf（item）來獲取它（在if（）中獲取一個項目，而在while（）中獲取所有它們）。 array.indexOf（item）返回索引或-1（如果找不到）。
|
一位朋友在Internet Explorer 8中遇到問題，向我展示了他的所作所為。我告訴他這是錯誤的，他告訴我他得到了答案這裡。當前的最佳答案不適用於所有瀏覽器（例如Internet Explorer 8），並且只會刪除該項目的首次出現。
從陣列中刪除所有實例
函數array_remove_index_by_value（arr，item）
{
對於（var i = arr.length; i--;）
{
if（arr [i] === item）{arr.splice（i，1）;}
}
}
它向後循環遍歷數組（因為索引和長度會隨著項目的刪除而改變），並在找到後刪除該項目。它適用於所有瀏覽器。
|
有兩種主要方法：
splice（）：anArray.splice（index，1）;
delete：刪除anArray [index];
對數組使用delete時要小心。這對刪除對象的屬性很有用，但對數組卻不太好。最好對數組使用拼接。
請記住，當對數組使用delete時，anArray.length可能會得到錯誤的結果。換句話說，delete會刪除該元素，但不會更新length屬性的值。
您還可以期望在使用刪除操作后索引號中出現漏洞，例如您最終可能會擁有使用delete之前的索引1、3、4、8、9和11，以及長度。在那種情況下，所有索引的for循環都會崩潰，因為索引不再是順序的。
如果由於某種原因而被迫使用delete，那麼當您需要遍歷數組時，應該為每個循環使用delete。實際上，如果可能，請始終避免使用索引for循環。這樣，代碼將更健壯，並且不易出現索引問題。
|
Array.prototype.remove_by_value = function（val）{
for（var i = 0; i row.id === 5）;
var remove = helper.remove（arr，row => row.name.startsWith（'BMW'））;
＃＃定義
var helper = {
//刪除並返回第一個匹配項
removeOne：函數（數組，謂詞）{
for（var i = 0; i [2，3，4]
|
您可以使用ES6。例如，在這種情況下刪除值“ 3”：
var array = ['1'，'2'，'3'，'4'，'5'，'6']
var newArray = array.filter（（value）=> value！='3'）;
console.log（newArray）;
輸出：
[“ 1”，“ 2”，“ 4”，“ 5”，“ 6”]
|
如果要刪除已刪除位置的新數組，則始終可以刪除特定元素並過濾掉該數組。對於未實現filter方法的瀏覽器，可能需要擴展array對象，但是從長遠來看，這很容易，因為您要做的就是：
var my_array = [1,2,3,4,5,6];
刪除my_array [4];
console.log（my_array.filter（function（a）{返回類型的！=='undefined';}）））;
它應該顯示[1、2、3、4、6]。
|
這是使用JavaScript從數組中刪除項目的幾種方法。
所描述的所有方法都不會改變原始數組，而是創建一個新數組。
如果您知道項目的索引
假設您有一個數組，並且想要刪除位置i處的項目。
一種方法是使用slice（）：
const項目= ['a'，'b'，'c'，'d'，'e'，'f']
const i = 3
constfilteredItems = items.slice（0，i）.concat（items.slice（i + 1，items.length））
console.log（filteredItems）
slice（）使用接收到的索引創建一個新數組。我們只需創建一個新數組，即從開始到要刪除的索引，然後從第一個位置開始連接另一個數組，該位置在我們刪除的數組之後到數組的結尾。
如果你知道價值
在這種情況下，一個不錯的選擇是使用filter（），它提供了一種更具聲明性的方法：
const項目= ['a'，'b'，'c'，'d'，'e'，'f']
const valueToRemove ='c'
constfilteredItems = items.filter（item => item！== valueToRemove）
console.log（filteredItems）
這將使用ES6箭頭功能。您可以使用傳統功能來支持舊版瀏覽器：
const項目= ['a'，'b'，'c'，'d'，'e'，'f']
const valueToRemove ='c'
constfilteredItems = items.filter（function（item）{
返回項目！== valueToRemove
}）
console.log（filteredItems）
或者，您可以使用Babel並將ES6代碼重新編譯回ES5，以使其更易於被舊的瀏覽器使用，但仍可以在代碼中編寫現代的JavaScript。
刪除多個項目
如果要刪除多個項目而不是單個項目怎麼辦？
讓我們找到最簡單的解決方案。
按索引
您可以只創建一個函數並刪除一系列項目：
const項目= ['a'，'b'，'c'，'d'，'e'，'f']
const removeItem =（items，i）=>
items.slice（0，i-1）.concat（items.slice（i，items.length））
讓FilterItems = removeItem（items，3）
filteredItems = removeItem（filteredItems，5）
//[“A B C D”]
console.log（filteredItems）
按價值
您可以在回調函數中搜索包含項：
const項目= ['a'，'b'，'c'，'d'，'e'，'f']
const valuesToRemove = ['c'，'d']
constfilteredItems = items.filter（item =>！valuesToRemove.includes（item））
// [[a]，“ b”，“ e”，“ f”]
console.log（filteredItems）
避免改變原始數組
splice（）（不要與slice（）混淆）會使原始數組發生突變，應避免使用。
（最初發佈在我的網站https://flaviocopes.com/how-to-remove-item-from-array/）
|
查看此代碼。它適用於所有主流瀏覽器。
remove_item = function（arr，value）{
var b ='';
為（b in arr）{
if（arr [b] === value）{
arr.splice（b，1）;
打破;
}
}
返回arr;
};
調用此功能
remove_item（array，value）;
|
ES6且無突變：（2016年10月）
const removeByIndex =（列表，索引）=>
[
... list.slice（0，index），
... list.slice（索引+1）
];
輸出= removeByIndex（[33,22,11,44]，1）// => [33,11,44]
console.log（輸出）
|
您可以使用lodash的_.pull（變異數組），_。pullAt（變異數組）或_.without（不變異數組），
var array1 = ['a'，'b'，'c'，'d']
_.pull（array1，'c'）
console.log（array1）// ['a'，'b'，'d']
var array2 = ['e'，'f'，'g'，'h']
_.pullAt（array2，0）
console.log（array2）// ['f'，'g'，'h']
var array3 = ['i'，'j'，'k'，'l']
var newArray = _.without（array3，'i'）// ['j'，'k'，'l']
console.log（array3）// ['i'，'j'，'k'，'l']
|
從數組中刪除特定的元素/字符串可以用一種方法完成：
theArray.splice（theArray.indexOf（“ stringToRemoveFromArray”），1）;
哪裡：
theArray：要從中刪除特定內容的數組
stringToRemoveFromArray：要刪除的字符串，1是要刪除的元素數量。
注意：如果“ stringToRemoveFromArray”不在數組中，則將刪除數組的最後一個元素。
在刪除元素之前，先檢查該元素是否存在於數組中始終是一個好習慣。
如果（theArray.indexOf（“ stringToRemoveFromArray”）> = 0）{
theArray.splice（theArray.indexOf（“ stringToRemoveFromArray”），1）;
}
如果您可以在客戶端計算機上訪問較新的Ecmascript版本（警告，在較舊的工作站上可能無法使用）：
var array = ['1'，'2'，'3'，'4'，'5'，'6']
var newArray = array.filter（（value）=> value！='3'）;
其中“ 3”是要從數組中刪除的值。
該數組將變為：['1'，'2'，'4'，'5'，'6']
|
好的，例如，您具有以下數組：
var num = [1,2,3,4,5];
我們要刪除數字4。您可以簡單地使用以下代碼：
num.splice（num.indexOf（4），1）; // num為[1、2、3、5]；
如果要重用此函數，請編寫一個可重用的函數，該函數將附加到本機數組函數，如下所示：
Array.prototype.remove = Array.prototype.remove ||函數（x）{
const i = this.indexOf（x）;
如果（i ===-1）
返回;
this.splice（i，1）; // num.remove（5）=== [1、2、3];
}
但是，如果有下面的數組而不是數組中有[5]個，那又如何呢？
var num = [5，6，5，4，5，1，5];
我們需要一個循環來檢查它們，但是更簡單，更有效的方法是使用內置的JavaScript函數，因此我們編寫了一個使用如下過濾器的函數：
const _removeValue =（arr，x）=> arr.filter（n => n！== x）;
// _ removeValue（[1、2、3、4、5、5、6、5]，5）//返回[1、2、3、4、6]
此外，還有第三方庫（例如Lodash或Underscore）可以幫助您完成此任務。有關更多信息，請查看lodash _.pull，_。pullAt或_.without。
|
性能
今天（2019-12-09）我在macOS v10.13.6（High Sierra）上針對所選解決方案進行了性能測試。我顯示了delete（A），但是我沒有將它與其他方法相比使用，因為它在數組中留下了空白。
結論
最快的解決方案是array.splice（C）（對於第二個小型陣列，Safari除外）
對於大型數組，array.slice + splice（H）是Firefox和Safari最快的不可變解決方案； Array.from（B）在Chrome中最快
可變解決方案通常比不可變解決方案快1.5到6倍
對於Safari上的小表，令人驚訝的是，可變解決方案（C）比不可變解決方案（G）慢
細節
在測試中，我以不同的方式從數組中刪除了中間元素。 A，C解決方案就位。 B，D，E，F，G，H解決方案是不可變的。
包含10個元素的數組的結果
在Chrome中，array.splice（C）是最快的就地解決方案。 array.filter（D）是最快的不可變解決方案。最慢的是array.slice（F）。您可以在此處在計算機上執行測試。
包含1.000.000元素的數組的結果
在Chrome中，array.splice（C）是最快的就地解決方案（刪除（C）速度很快-但它在數組中留有一個空插槽（因此它不執行“完全刪除”））。 array.slice-splice（H）是最快的不可變解決方案。最慢的是array.filter（D和E）。您可以在此處在計算機上執行測試。
var a = [0，1，2，3，4，5，6，7，8，9];
var log =（letter，array）=> console.log（letter，array.join`，`）;
函數A（數組）{
var index = array.indexOf（5）;
刪除數組[索引];
log（'A'，array）;
}
函數B（數組）{
var index = array.indexOf（5）;
var arr = Array.from（array）;
arr.splice（索引，1）
log（'B'，arr）;
}
函數C（array）{
var index = array.indexOf（5）;
array.splice（index，1）;
log（'C'，array）;
}
函數D（array）{
var arr = array.filter（item => item！== 5）
log（'D'，arr）;
}
函數E（array）{
var index = array.indexOf（5）;
var arr = array.filter（（item，i）=> i！==索引）
log（'E'，arr）;
}
函數F（array）{
var index = array.indexOf（5）;
var arr = array.slice（0，index）.concat（array.slice（index + 1））
log（'F'，arr）;
}
函數G（array）{
var index = array.indexOf（5）;
var arr = [... array.slice（0，index），... array.slice（index + 1）]
log（'G'，arr）;
}
函數H（array）{
var index = array.indexOf（5）;
var arr = array.slice（0）;
arr.splice（index，1）;
log（'H'，arr）;
}
A（[... a]）;
B（[... a]）;
C（[... a]）;
D（[... a]）;
E（[... a]）;
F A]）;
G（[... a]）;
哈]）;
此代碼段僅顯示性能測試中使用的代碼-本身不執行測試。
瀏覽器比較：Chrome v78.0.0，Safari v13.0.4和Firefox v71.0.0
|
我對JavaScript很陌生，需要此功能。我只是這樣寫：
函數removeFromArray（array，item，index）{
while（（（index = array.indexOf（item））> -1）{
array.splice（index，1）;
}
}
然後，當我想使用它時：
//設置一些虛擬數據
var dummyObj = {name：“喵”};
var dummyArray = [dummyObj，“ item1”，“ item1”，“ item2”];
//刪除虛擬數據
removeFromArray（dummyArray，dummyObj）;
removeFromArray（dummyArray，“ item2”）;
輸出-如預期。
[“ item1”，“ item1”]
您可能與我有不同的需求，因此可以輕鬆對其進行修改適合他們。我希望這可以幫助別人。
|
如果數組中有復雜的對象，可以使用過濾器嗎？
在$ .inArray或array.splice不太容易使用的情況下。特別是如果對像在數組中可能很淺。
例如。如果您有一個具有ID字段的對象，並且希望將該對像從數組中刪除：
this.array = this.array.filter（function（element，i）{
返回element.id！== idToRemove;
}）;
|
我想根據ECMAScript 6進行回答。假設您有一個如下數組：
令arr = [1,2,3,4];
如果要刪除像2這樣的特殊索引，請編寫以下代碼：
arr.splice（2，1）; // => arr變為[1,2,4]
但是，如果您要刪除特殊項目（例如3）並且不知道其索引，請執行以下操作：
arr = arr.filter（e => e！== 3）; // => arr變為[1,2,4]
提示：請使用箭頭函數進行過濾器回調，除非您得到一個空數組。
|
更新：僅當您無法使用ECMAScript 2015（以前稱為ES6）時，才建議使用此方法。如果可以使用它，此處的其他答案將提供更整潔的實現。
這裡的要點將解決您的問題，還將刪除所有出現的參數，而不僅僅是1（或指定值）。
Array.prototype.destroy = function（obj）{
//如果未找到並刪除任何對象，則返回null
var destroy = null;
for（var i = 0; i 3
x.destroy（false）; // =>否
X; // => [1,2，true，undefined]
x.destroy（true）; // =>是
x.destroy（未定義）; // =>未定義
X; // => [1，2]
x.destroy（3）; // => null
X; // => [1，2]
|
ES10更新
這篇文章總結了自ECMAScript 2019（ES10）起從數組中刪除元素的常用方法。
1.一般情況
1.1。使用.splice（）按值刪除Array元素
|就地：是|
|刪除重複項：是（循環），否（indexOf）|
|按值/索引：按索引|
如果知道要從數組中刪除的值，則可以使用splice方法。首先，您必須確定目標項目的索引。然後，您將索引用作開始元素，並僅刪除一個元素。
//使用“ for”循環
const arr = [1,2,3,4,5,6,7,8,9,0];
for（令i = 0; i <長度; i ++）{
如果（arr [i] === 5）{
arr.splice（i，1）;
}
} // => [1、2、3、4、6、7、8、9、0]
//使用.indexOf（）方法
const arr = [1,2,3,4,5,6,7,8,9,0];
const i = arr.indexOf（5）;
arr.splice（i，1）; // => [1、2、3、4、6、7、8、9、0]
1.2。使用.filter（）方法刪除Array元素
|就地：否|
|刪除重複項：是|
|按值/索引：按值|
通過提供過濾功能，可以從數組中過濾出特定元素。然後為數組中的每個元素調用此函數。
常量值= 3
設arr = [1、2、3、4、5、3]
arr = arr.filter（item =>項目！==值）
console.log（arr）
// [1，2，4，5]
1.3。通過擴展Array.prototype刪除Array元素
|就地：是/否（取決於實現）|
|刪除重複項：是/否（取決於實現）|
|按值/索引：按索引/按值（取決於實現）|
Array的原型可以使用其他方法擴展。這樣，這些方法將可用於創建的數組。
注意：從標準的JavaScript庫（例如Array）擴展對象的原型被認為是一種反模式。
//通過值實現就地刪除所有內容
Array.prototype.remove = function（item）{
for（讓i = 0; i = ES10）刪除數組元素
|就地：否|
|刪除重複項：是|
|按值/索引：按值|
ES10引入了Object.fromEntries，可以是用於從任何類似Array的對象創建所需的Array並在此過程中過濾不需要的元素。
const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values（Object.fromEntries（
Object.entries（對象）
.filter（（[[key，val]）=> val！== valueToRemove）
））;
console.log（arr）; // [1,2,4]
2.特殊情況
2.1刪除元素（如果它在數組的末尾）
2.1.1。更改數組長度
|就地：是|
|刪除重複項：否|
|按值/索引：N / A |
通過將length屬性設置為小於當前值的值，可以從數組末尾刪除JavaScript Array元素。索引大於或等於新長度的任何元素將被刪除。
const arr = [1,2,3,4,5,6];
arr.length = 5; //設置刪除元素的長度
console.log（arr）; // [1、2、3、4、5]
2.1.2。使用.pop（）方法
|就地：是|
|刪除重複項：否|
|按值/索引：N / A |
pop方法刪除數組的最後一個元素，返回該元素，並更新length屬性。 pop方法修改在其上調用它的數組，這意味著與使用delete不同，最後一個元素被完全刪除並且數組長度減小。
const arr = [1,2,3,4,5,6];
arr.pop（）; //返回6
console.log（arr）; // [1、2、3、4、5]
2.2。如果元素在數組的開頭，則將其刪除
|就地：是|
|刪除重複項：否|
|按值/索引：N / A |
.shift（）方法的工作原理與pop方法非常相似，只是它刪除了JavaScript數組的第一個元素而不是最後一個元素。刪除元素後，其餘元素將向下移動。
const arr = [1、2、3、4];
arr.shift（）; //返回1
console.log（arr）; // [2，3，4]
2.3。如果元素是數組中的唯一元素，則將其刪除
|就地：是|
|刪除重複項：N / A |
|按值/索引：N / A |
最快的技術是將數組變量設置為空數組。
令arr = [1];
arr = []; //空數組
通過將長度設置為0，可以使用2.1.1中的替代技術。
|
您絕對不應更改數組。因為這與功能編程模式相反。您可以使用ECMAScript 6方法過濾器創建一個新數組而不引用要更改數據的數組;
var myArray = [1,2,3,4,5,6];
假設您要從數組中刪除5，您可以像這樣簡單地進行操作：
myArray = myArray.filter（值=>值！== 5）;
這將為您提供一個沒有要刪除的值的新數組。因此結果將是：
[1、2、3、4、6]； //已從該數組中刪除5
為了進一步理解，您可以閱讀Array.filter上的MDN文檔。
|
一種更現代的ECMAScript 2015（以前稱為Harmony或ES 6）方法。鑑於：
const項目= [1、2、3、4]；
const index = 2;
然後：
items.filter（（x，i）=> i！==索引）;
屈服：
[1、2、4]
您可以使用Babel和polyfill服務來確保所有瀏覽器都很好地支持此功能。
|
如果該元素存在多個實例，則可以進行向後循環以確保不破壞索引。
var myElement =“巧克力”;
var myArray = ['chocolate'，'poptart'，'poptart'，'poptart'，'chocolate'，'poptart'，'poptart'，'chocolate']；
/ *重要代碼* /
for（var i = myArray.length-1; i> = 0; i--）{
如果（myArray [i] == myElement）myArray.splice（i，1）;
}
console.log（myArray）;
現場演示
|
您的數組中有1到9，並且要刪除5。使用以下代碼：
var numberArray = [1、2、3、4、5、6、7、8、9]；
var newNumberArray = numberArray.filter（m => {
返回m！== 5;
}）;
console.log（“新數組，已刪除5個”，newNumberArray）;
如果要多個值。範例：-1,7,8
var numberArray = [1、2、3、4、5、6、7、8、9]；
var newNumberArray = numberArray.filter（m => {
return（m！== 1）&&（m！== 7）&&（m！== 8）;
}）;
console.log（“新數組，刪除1,7和8”，newNumberArray）;
如果要刪除數組中的數組值。範例：[3,4,5]
var numberArray = [1、2、3、4、5、6、7、8、9]；
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter（m => {
return！removebleArray.includes（m）;
}）;
console.log（“刪除新數組[[3,4,5]”，newNumberArray）;
包括支持的瀏覽器鏈接。
|
1個
2
3
4
下一個
高度活躍的問題。贏得10個聲譽才能回答這個問題。信譽要求有助於保護該問題免受垃圾郵件和非答復活動的侵害。
不是您要找的答案？瀏覽其他標記有javascript數組的問題，或提出您自己的問題。