Hindi mo kai>indexOf o splice . Gayunpaman, ito ay mas mahusay na gumagana kung nais mong alisin lamang ang isang pangyayari ng item.

Hanapin at ilipat (ilipat):

 function move(arr, val) { var j = 0; for (var i = 0, l = arr.length; i < l; i++) { if (arr[i] !== val) { arr[j++] = arr[i]; } } arr.length = j; } 

Gamitin ang indexOf at splice (indexof):

 function indexof(arr, val) { var i; while ((i = arr.indexOf(val)) != -1) { arr.splice(i, 1); } } 

Gumamit lamang ng pag- splice :

 function splice(arr, val) { for (var i = arr.length; i--;) { if (arr[i] === val) { arr.splice(i, 1); } } } 

Lead oras para sa nodejs para sa isang array na may 1000 na elemento (isang average ng higit sa 10,000 nagpapatakbo):

Ang index ay tungkol sa 10 beses na mas mabagal kaysa sa paglipat. Kahit na ito ay pinabuting sa pamamagitan ng pag-alis ng indexOf tawag sa isang paghugpong, ito ay gumaganap ng mas masahol kaysa sa paglipat.

 Remove all occurrences: move 0.0048 ms indexof 0.0463 ms splice 0.0359 ms Remove first occurrence: move_one 0.0041 ms indexof_one 0.0021 ms 

Ang pinakamadaling paraan:

 var index = array.indexOf(item); if(index != -1) array.splice( index, 1 ); 

Masyadong matanda upang sagutin, ngunit maaari niyang tulungan ang isang tao sa pamamagitan ng pagbibigay ng isang predicate sa halip ng isang halaga.

TANDAAN: ito ay mai-update ang array na ito at ibalik ang mga apektadong linya.

Paggamit ng

 var removed = helper.removeOne(arr, row => row.id === 5 ); var removed = helper.remove(arr, row => row.name.startsWith('BMW')); 

Kahulugan

 var helper = { // Remove and return the first occurrence removeOne: function(array, predicate) { for (var i = 0; i < array.length; i++) { if (predicate(array[i])) { return array.splice(i, 1); } } }, // Remove and return all occurrences remove: function(array, predicate) { var removed = []; for (var i = 0; i < array.length;) { if (predicate(array[i])) { removed.push(array.splice(i, 1)); continue; } i++; } return removed; } }; 

Inilathala ni John Resig ang mahusay na pagpapatupad :

 // Array Remove - By John Resig (MIT Licensed) Array.prototype.remove = function(from, to) { var rest = this.slice((to || from) + 1 || this.length); this.length = from < 0 ? this.length + from : from; return this.push.apply(this, rest); }; 

Kung hindi mo nais na pahabain ang pandaigdigang bagay, maaari kang gumawa ng isang bagay tulad ng sumusunod:

 // Array Remove - By John Resig (MIT Licensed) Array.remove = function(array, from, to) { var rest = array.slice((to || from) + 1 || array.length); array.length = from < 0 ? array.length + from : from; return array.push.apply(array, rest); }; 

Ngunit ang pangunahing dahilan na i-publish ko ito ay upang bigyan ng babala ang mga gumagamit tungkol sa alternatibong pagpapatupad na iminungkahi sa mga komento sa pahinang ito (Disyembre 14, 2007):

 Array.prototype.remove = function(from, to){ this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to); return this.length; }; 

Mukhang mahusay na gumagana sa simula, ngunit sa pamamagitan ng masakit na proseso natuklasan ko na hindi ito gumagana, sinusubukang alisin ang pangalawang sa huling sangkap sa array. Halimbawa, kung mayroon kang 10-elementong array at sinusubukan mong tanggalin ang ika-9 na sangkap na may ganitong:

 myArray.remove(8); 

Bi>

Maaaring gamitin ang Underscore.js upang malutas ang mga problema sa maraming mga browser. Gumagamit ito ng mga built-in na pamamaraan ng browser, kung mayroon man. Kung nawawala ang mga ito, tulad ng kaso sa mas lumang mga bersyon ng Internet Explorer, gumagamit ito ng sarili nitong mga pamamaraan.

Isang simpleng halimbawa para sa pag-alis ng mga elemento mula sa isang array (mula sa isang website):

 _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4] 

Maaari mong gawin ito madali sa paraan ng filter :

 function remove(arrOriginal, elementToRemove){ return arrOriginal.filter(function(el){return el !== elementToRemove}); } console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) ); 

Inaalis nito ang lahat ng mga elemento mula sa array, at gumagana rin nang mas mabilis kaysa sa slice at indexOf na kumbinasyon.

Kung nais mong tanggalin ang isang bagong array na may mga tinanggal na posisyon, maaari mong laging tanggalin ang isang partikular na elemento at i-filter ang array. Maaaring kai>array na bagay para sa mga browser na hindi nagpapatupad ng paraan ng filter, ngunit sa katagalan ito ay madali, dahil ang lahat ng iyong ginagawa ay ang mga sumusunod:

 var my_array = [1,2,3,4,5,6]; delete my_array[4]; console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); 

Dapat ipakita ang [1, 2, 3, 4, 6]

Maaari mong gamitin ang ES6.

 var array=['1','2','3','4','5','6'] var index = array.filter((value)=>value!='3'); 

Lumabas:

 ["1", "2", "4", "5", "6"] 

Tingnan ang code na ito. Gumagana ito sa bawat pangunahing browser. .

 remove_item = function (arr, value) { var b = ''; for (b in arr) { if (arr[b] === value) { arr.splice(b, 1); break; } } return arr; } 

Tawagan ang function na ito

 remove_item(array,value); 

Maaari mong gamitin ang lodash _. pull (mutate array), _.pullAt (mutate array) o _. nang wa> (hindi mutate ang array),

 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'] 

OK, halimbawa, mayroon kang isang array sa ibaba:

 var num = [1, 2, 3, 4, 5]; 

At gusto naming tanggalin ang numero 4, maaari mo lamang gawin ang sumusunod na code:

 num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5]; 

Kung gagamitin mo muli ang function na ito, sumulat ka ng isang function ng muling paggamit na nakagapos sa function na Native array, tulad ng ipinapakita sa ibaba:

 Array.prototype.remove = Array.prototype.remove || function(x) { const i = this.indexOf(x); if(i===-1) return; this.splice(i, 1); //num.remove(5) === [1, 2, 3]; } 

Ngunit kung paano ang tungkol sa kung mayroon kang isang array sa ibaba, at i>

 var num = [5, 6, 5, 4, 5, 1, 5]; 

Kai>

 const _removeValue = (arr, x) => arr.filter(n => n!==x); //_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6] 

Mayroon ding mga third-party na mga aklatan upang matulungan kang gawin ito, tulad ng Lodash o Underscore, para sa karagdagang impormasyon sa lodash _.pull, _.pullAt o _.without.

Bago ako sa javascript at kai>

 function removeFromArray(array, item, index) { while((index = array.indexOf(item)) > -1) { array.splice(index, 1); } } 

Pagkatapos, kapag gusto kong gamitin ito:

 //Set-up some dummy data var dummyObj = {name:"meow"}; var dummyArray = [dummyObj, "item1", "item1", "item2"]; //Remove the dummy data removeFromArray(dummyArray, dummyObj); removeFromArray(dummyArray, "item2"); 

Lumabas - tulad ng inaasahan. ["item1", "item1"]

Maaari kang magkaroon ng iba't ibang pangangai>

ES6 at wa>

 const removeByIndex = (list, index) => [ ...list.slice(0, index), ...list.slice(index + 1) ]; 

Pagkatapos:

 removeByIndex([33,22,11,44],1) //=> [33,11,44] 

Update: Ang pamamaraan na ito ay inirerekomenda lamang kung hindi mo magamit ang ECMAScript 2015 (dating kilala bi>

Ang ibig sabihin dito ay malulutas ang iyong problema, pati na rin tanggalin ang lahat ng mga pangyayari ng argument, hindi lamang 1 (o ang tinukoy na halaga).

 Array.prototype.destroy = function(obj){ // Return null if no objects were found and removed var destroyed = null; for(var i = 0; i < this.length; i++){ // Use while-loop to find adjacent equal objects while(this[i] === obj){ // Remove this[i] and store it within destroyed destroyed = this.splice(i, 1)[0]; } } return destroyed; } 

Application:

 var x = [1, 2, 3, 3, true, false, undefined, false]; x.destroy(3); // => 3 x.destroy(false); // => false x; // => [1, 2, true, undefined] x.destroy(true); // => true x.destroy(undefined); // => undefined x; // => [1, 2] x.destroy(3); // => null x; // => [1, 2] 

Kung mayroon kang mga kumplikadong bagay sa isang array, maaari kang gumamit ng mga filter? Sa mga sitwasyon kung saan ang $ .inArray o array.splice ay hindi madaling gamitin. Lalo na kung ang mga bagay ay posibleng maliit sa array.

halimbawa. kung mayroon kang isang bagay na may pat>

 this.array = this.array.filter(function(element, i) { return element.id !== idToRemove; }); 

Narito ang i>alisin ang isang elemento mula sa isang array gamit ang javascript .

Ang lahat ng mga pamamaraan na inilarawan ay hindi nagbabago sa orihinal na array at sa halip ay lumikha ng bago.

Kung alam mo ang index ng item

Ipagpalagay na mayroon kang isang array at nais mong tanggalin ang isang elemento sa posisyon i .

Ang isang paraan ay ang paggamit ng slice() :

 const items = ['a', 'b', 'c', 'd', 'e', 'f'] const valueToRemove = 'c' const filteredItems = items.filter(item => item !== valueToRemove) console.log(filteredItems) 

Ginagamit nito ang mga function ng ES6 arrow. Maaari mong gamitin ang mga tradisyunal na tampok upang suportahan ang mga mas lumang browser:

 const items = ['a', 'b', 'c', 'd', 'e', 'f'] const removeItem = (items, i) => items.slice(0, i-1).concat(items.slice(i, items.length)) let filteredItems = removeItem(items, 3) filteredItems = removeItem(filteredItems, 5) //["a", "b", "c", "d"] console.log(filteredItems) 

Ayon sa halaga

Maaari kang maghanap para sa pagsasama sa loob ng pag-andar ng callback:

https://flaviocopes.com/how-to-remove-item-from-array/ )