Paano tanggalin ang isang tiyak na sangkap mula sa isang array sa javascript?
Mayroon akong isang hanay ng mga integer, at ginagamit ko ang .push()
paraan upang magdagdag ng mga elemento dito.
Mayroon bang isang madaling paraan upang alisin ang isang partikular na item mula sa isang array? Ang katumbas ng isang bagay tulad ng array.remove(int);
.
Kai>
Hanapin ang index
ng elemento ng array na gusto mong alisin, pagkatapos tanggalin ang index na ito gamit ang splice
.
Binabago ng paraan ng pag-splice () ang mga nilalaman ng isang array sa pamamagitan ng pagtanggal ng mga umiiral na elemento at / o pagdaragdag ng mga bagong elemento.
suporta ng browser para sa indexOf ay limitado; Hindi sinusuportahan ito sa Internet Explorer 7 at 8.Kung kai>indexOf sa isang hindi sinusuportahang browser, subukan ang
polyfill
susunod napolyfill
. Maghanap ng higit pang impormasyon tungkol sapolyfill
dito .Array.prototype.indexOf || (Array.prototype.indexOf = function(d, e) { var a; if (null == this) throw new TypeError('"this" is null or not defined'); var c = Object(this), b = c.length >>> 0; if (0 === b) return -1; a = +e || 0; Infinity === Math.abs(a) (a = 0); if (a >= b) return -1; for (a = Math.max(0 <= a ? a : b - Math.abs(a), 0); a < b;) { if (a in c c[a] === d) return a; a++ } return -1 });
Hindi ko alam kung paano mo inaasahan na ang array.remove(int)
ay kumilos. Mayroong tatlong posibilidad na maaari mong isipin.
Upang alisin ang isang sangkap ng array na may index ng i
:
array.splice(i, 1);
Kung nais mong alisin ang bawat item na may isang halaga ng number
mula sa array:

for(var i = array.length - 1; i >= 0; i--) { if(array[i] === number) { array.splice(i, 1); } }
Kung nais mo lamang gumawa ng isang sangkap na may index, wala na i
umiiral, ngunit ayaw mo na mag-iba ang mga index ng ibang mga elemento:
delete array[i];
Na-edit 2016 Oktubre
- Gawing simple, intuitive at tahasang ( https://en.wikipedia.org/wiki/Occam%27s_razor )
- Gawin itong hindi nagbabago (ang orihinal na array ay mananatiling hindi nagbabago)
- Gawin ito sa karaniwang mga pag-andar ng JS, kung hindi sinusuportahan ng iyong browser ang mga ito - gumamit ng polyfill
Sa code na ito halimbawa, ginagamit ko ang array.filter (...) function upang alisin ang mga hindi gustong elemento mula sa isang array, ang function na ito ay hindi nagbabago sa orihinal na array at lumilikha ng bago. bersyon 1.5), isaa>filter ng polyilla ng Mozilla .
Pagtanggal ng Item (ECMA-262 Edition 5 code aka oldstyle JS)
var value = 3 var arr = [1, 2, 3, 4, 5, 3] arr = arr.filter(function(item) { return item !== value }) console.log(arr) // [ 1, 2, 4, 5 ]
Pagtanggal ng item (ES2015 code)
let value = 3 let arr = [1, 2, 3, 4, 5, 3] arr = arr.filter(item => item !== value) console.log(arr) // [ 1, 2, 4, 5 ]
MAHALAGA ES2015 "() => {}" Ang syntax ng pag-andar ng arrow ay hindi sinusuportahan sa IE sa pangkalahatan, ang Chrome hanggang sa bersyon 45, ang Firefox hanggang sa bersyon 22, Safari hanggang sa bersyon 10. Upang gamitin ang syntax ng ES2015 sa mas lumang mga browser, maaari mong gamitin ang BabelJS
Tinatanggal ang maramihang item (ES2016 code)
Ang isang karagdagang kalamangan ng pamamaraang ito ay ang maaari mong tanggalin ang i>
let forDeletion = [2, 3, 5] let arr = [1, 2, 3, 4, 5, 3] arr = arr.filter(item => !forDeletion.includes(item)) // !!! Read below about array.includes(...) support !!! console.log(arr) // [ 1, 4 ]
MAHALAGA "array.includes (...)" ay hindi sinusuportahan sa IE sa lahat, Chrome hanggang sa bersyon 47, Firefox hanggang sa bersyon 43, Safari hanggang sa bersyon 9 at Edge hanggang sa bersyon 14, kaya narito ang Mozilla polyfields
Alisin ang maraming elemento (advanced na pang-eksperimentong javascript ES2018?)
// array-lib.js export function remove(...forDeletion) { return this.filter(item => !forDeletion.includes(item)) } // main.js import { remove } from './array-lib.js' let arr = [1, 2, 3, 4, 5, 3] // :: This-Binding Syntax Proposal // using "remove" function as "virtual method" // without extending Array.prototype arr = arr::remove(2, 3, 5) console.log(arr) // [ 1, 4 ]
Tulong
Depende kung gusto mong i-save ang wa>
Kung kai>
delete array[ index ];
Kung hindi mo ito ginagawa, dapat mong gamitin ang paraan ng pag- splice :
array.splice( index, 1 );
At kung kai>
var value = array.splice( index, 1 )[0];
Kung nais mong gawin ito sa isang tiyak na pagkakasunud-sunod, maaari mong gamitin ang array.pop()
para sa huli o array.shift()
para sa una (at parehong ibalik ang halaga ng elemento masyadong).
At kung hindi mo alam ang index ng isang item, maaari mong gamitin ang array.indexOf( item )
upang makuha ito (sa if()
upang makakuha ng isang item o sa while()
upang makuha ang lahat ng mga ito). array.indexOf( item )
nagbabalik ng index, o -1 kung hindi natagpuan.
Ang isang kaibigan ay nagkaroon ng problema sa Internet Explorer 8 , at ipinakita niya sa akin kung ano ang ginawa niya. Sinabi ko sa kanya na ito ay mali, at sinabi niya sa akin na nakatanggap siya ng sagot dito. Ang kasalukuyang pinakamataas na sagot ay hindi gagana sa lahat ng mga browser (halimbawa, Internet Explorer 8), at aalisin lamang nito ang unang pangyayari ng item.
Alisin ang ALL instances mula sa array
function remove(arr, item) { for (var i = arr.length; i--;) { if (arr[i] === item) { arr.splice(i, 1); } } }
Ito ay gumagalaw paatras sa pamamagitan ng array (dahil ang mga indeks at haba ay magbabago kapag inalis ang mga elemento) at tinatanggal ang elemento kung ito ay natagpuan. Gumagana ito sa lahat ng mga browser.
Mayroong dalawang pangunahing pamamaraan:
anArray.splice(index, 1);
() :anArray.splice(index, 1);
tanggalin :
delete anArray[index];
Mag-ingat kapag gumamit ka ng delete para sa isang array. Ito ay mabuti para sa pag-alis ng mga katangian ng bagay, ngunit hindi mabuti para sa arrays. Mas mahusay na gamitin ang pag- splice
para sa arrays.
Tandaan na kapag gumamit ka ng delete
para sa isang array, maaari kang makakuha ng hindi tamang mga resulta para sa anArray.length
. Sa madaling salita, delete
pagtanggal ng elemento ngunit hindi na-update ang halaga ng haba ng ari-arian.
Maaari mo ring asahan ang mga butas sa mga numero ng index pagkatapos gamitin ang isang pagtanggal, halimbawa. maaari kang makakuha ng mga index ng 1,3,4,8,9,11 at haba, tulad ng bago ito gamit ang pagtanggal. Sa kasong ito, ang lahat ng na-index for
loop ay hahatiin, dahil ang mga index ay hindi na pare-pareho.
Kung para sa i>delete , pagkatapos ay kai>for each
loop kapag kai>
Array.prototype.remByVal = function(val) { for (var i = 0; i < this.length; i++) { if (this[i] === val) { this.splice(i, 1); i--; } } return this; } //Call like [1, 2, 3, 4].remByVal(3);
116
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) ];
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/ )
Hindi mo dapat pagbago ng array array. Sapagkat sinasalungat nito ang functional programming pattern. Ang maaari mong gawin ay lumikha ng isang bagong array na wa>filter paraan;
var myArray = [1,2,3,4,5,6];
Ipagpalagay na nais mong tanggalin ang 5
mula sa isang array, maaari mo lamang gawin ito tulad nito.
myArray = myArray.filter(value => value !== 5);
Ito ay magbibigay sa iyo ng isang bagong array nang wa>
[1,2,3,4,6]; // 5 has been removed from this array
Para sa karagdagang pag-unawa, maaari mong basahin ang dokumentasyon ng MDN sa Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
Mas moderno, ECMAScript 2015 (dating kilala bi>
const items = [1, 2, 3, 4]; const index = 2;
Pagkatapos:
items.filter((x, i) => i !== index);
Cession:
[1, 2, 4]
Maaari mong gamitin ang Babel at ang serbisyong polyfill upang ang mga browser ay mabuti.
Alam ko na maraming mga sagot, ngunit marami sa kanila ang tila kumplikado sa problema. Narito ang isang simple, recursive na paraan upang alisin ang lahat ng mga pagkakataon ng isang key - ito ay tumatawag sa sarili hanggang sa isang index ay natagpuan. Oo, gumagana lamang ito sa mga browser na may indexOf
, ngunit ito ay simple at maaaring madaling mapunan.
Awtonomong pag-andar
function removeAll(array, key){ var index = array.indexOf(key); if(index === -1) return; array.splice(index, 1); removeAll(array,key); }
Pamamaraan ng tularan
Array.prototype.removeAll = function(key){ var index = this.indexOf(key); if(index === -1) return; this.splice(index, 1); this.removeAll(key); }
Mayroon akong isa pang magandang solusyon para sa pag-alis mula sa isang array:
var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']; const result = words.filter(word => word.length > 6); console.log(result); // expected output: Array ["exuberant", "destruction", "present"]
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
Maaari kang gumawa ng isang reverse loop upang tiyakin na hindi mo screwing down ang mga indeks kung mayroong maraming mga pagkakataon ng elemento.
var myElement = "chocolate"; var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate']; for (var i = myArray.length - 1; i >= 0; i--) { if (myArray[i] == myElement) myArray.splice(i, 1); }
Live na demo
Batay sa lahat ng mga sagot na halos tama, at isinasaa>
function arrayWithout(arr, values) { var isArray = function(canBeArray) { if (Array.isArray) { return Array.isArray(canBeArray); } return Object.prototype.toString.call(canBeArray) === '[object Array]'; }; var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1); var arrCopy = arr.slice(0); for (var i = arrCopy.length - 1; i >= 0; i--) { if (excludedValues.indexOf(arrCopy[i]) > -1) { arrCopy.splice(i, 1); } } return arrCopy; }