Poistaminen javascript-taulukosta. Javascript - määritelty - Kuinka poistaa elementti taulukosta arvon mukaan? Esittely tietyn elementin poistamisesta liitosmenetelmällä

Kuvasin vain joitakin menetelmiä taulukoiden kanssa työskentelyyn.

Täällä puhumme taulukkoelementtien lisäämisestä ja poistamisesta. Tietoja taulukon kääntämisestä ja lajittelusta sekä taulukoiden leikkaamisesta, korvaamisesta ja yhdistämisestä.

Elementtien lisääminen taulukkoon.

Voit käyttää pituus-ominaisuutta lisätäksesi uusia elementtejä taulukkoon:

Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "Yahoo!"; console.log(myArray); // ["Apple", "Microsoft", "Google", "Facebook", "Yahoo!"]

Tämä toimii, koska... taulukon elementit numeroidaan nollasta alkaen ja pituus on yksi enemmän. Pituus vastaa aina indeksiä + 1 , joten on erittäin helppoa lisätä uusi elementti taulukon loppuun. Kummallista kyllä, voit lisätä elementin kohtaan, joka on paljon suurempi kuin itse taulukon pituus:

Var myArray = ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"]; myArray = "Lindsey Buckingham"; console.log(myArray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", undefined × 95, "Lindsey Buckingham"] console.log(myArray.length); // 100

Kuten kommenteista näkyy, tämä lisää 95 tyhjää paikkaa ja elementin "Lindsey Buckingham" taulukon loppuun. Tämän jälkeen saamme pituuden 100. Toinen tapa lisätä uusi elementti taulukkoon on käyttää push()-menetelmää:

Var myArray = ["Paul McCartney", "John Lennon", "George Harrison"]; myArray.push("Ringo Starr", "George Martin"); console.log(myArray); // ["Paul McCartney", "John Lennon", "George Harrison", "Ringo Starr", "George Martin"]

Push()-metodi palauttaa aina taulukon uuden pituuden (tapauksessamme 5). Voit lisätä elementin käyttämällä splice():

Var myArray = ["tammenterho", "pyökki", "mongongo", "makadamia"]; myArray.splice(2, 0, "cashhew"); // lisää "cashew" indeksiin 2 console.log(myArray); // ["tammenterho", "pyökki", "cashew", "mongongo", "makadamia"]

Kun toinen argumentti on 0, se tarkoittaa, että mitään elementtiä ei poisteta, ja siksi kaikki myöhemmät argumentit lisätään taulukkoon ensimmäisessä argumentissa määritettyyn kohtaan.

Elementtien poistaminen taulukosta

Elementin poistaminen on hieman vaikeampaa kuin sen lisääminen. Voit poistaa elementin taulukon lopusta käyttämällä pop():

Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop(); console.log(myArray); // ["7-up", "Sprite", "Ginger Ale"]

Pop()-menetelmä poistaa aina taulukon viimeisen elementin ja palauttaa sen.

Voit myös käyttää splice()-menetelmää:

Var myArray = ["kassava", "muskottipähkinä", "lupiini", "raparperi"]; myArray.splice(2, 1); // poista elementti indeksillä 2 console.log(myArray); // ["kassava", "muskottipähkinä", "raparperi"]

Toisin kuin splice()-menetelmä, jota käytetään elementtien lisäämiseen, tässä toinen argumentti on 1, joka sanoo, että haluamme poistaa elementin indeksillä 2 (tai 3. peräkkäin). Tässä tapauksessa "lupiini"-elementti poistettiin.

Voit poistaa taulukkoelementin käyttämällä delete-operaattoria:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log(myArray.length); // 4 poista myArray; // poista Eliza console.log(myArray.length); // 4 console.log(myArray); // ["Byte Bandit", määrittelemätön × 1, "Jeefo", "Michelangelo"]

Ensimmäinen tärkeä huomautus: delete() ei muuta taulukon pituutta elementin poistamisen jälkeen (vaikka se olisi taulukon viimeinen elementti). Toinen: delete() muuttaa poistettavan elementin arvon määrittelemättömäksi, joten kun sitä kutsutaan myArray = undefined .

Hyvä tapa poistaa elementti taulukosta on käyttää John Resigin Array.removea. Alla on hänen sivultaan otettu käyttöesimerkki:

// Array Remove - Kirjoittaja John Resig (MIT Licensed) Array.prototype.remove = function(from, to) ( var rest = this.slice((to || from) + 1 || this.length); this.length = alkaen< 0 ? this.length + from: from; return this.push.apply(this, rest); }; // Удаление 2 элемента из массива array.remove(1); // Удаление 2-ого элемента с конца массива array.remove(-2); // Удаление второго и третьего элемента array.remove(1,2); // Удаление последнего и предпоследнего элемента array.remove(-2,-1);

Haluat ehkä tarkastella Viral Patelin ratkaisua, joka on yksi Underscore.js:n funktioista, tai jQueryn grep().

Lisäksi JavaScriptissä on shift()-menetelmä, joka poistaa taulukon ensimmäisen elementin ja palauttaa sen arvon. Katsotaanpa koodia:

Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log(myArray.length); // 4 var firstItem = myArray.shift(); console.log(firstItem); // Matt Kramer konsoli.log(myArray.length); // 3 console.log(myArray); // ["Jason Bieler", "Tom Defile", "Phil Varone"]

Shift()-menetelmällä poistimme elementin, mutta tallensimme sen arvon firstItem-muuttujaamme. Taulukon pituus muuttui 4:stä 3:een.

Tämä menetelmä voi olla hyödyllinen push()-menetelmän yhteydessä. Käyttämällä niitä yhdessä voimme tehokkaasti jonottaa elementtejä taulukkoon. Säilytämme taulukon pituuden poistamalla elementin alusta ja lisäämällä uuden loppuun.

Sitä vastoin voimme käyttää unshift()-menetelmää lisätäksesi elementin taulukon alkuun:

Var myArray = ["apito", "castanets", "maraca"]; console.log(myArray.length); // 3 myArray.unshift("chime bar", "tan-tan"); console.log(myArray.length); // 5 console.log(myArray); // ["chime bar", "tan-tan", "apito", "castanets", "maraca"]

Käyttämällä unshift()-menetelmää pop()-menetelmän kanssa voit luoda jonoja käänteisesti lisäämällä elementtejä taulukon alkuun ja poistamalla elementtejä taulukon lopusta.

Matriisin elementtien kääntäminen ja lajittelu.

Kääntääksesi taulukon elementit, voimme käyttää reverse():

Var myArray = ["lähtölaskenta", "lopullinen", "the"]; console.log(myArray); // ["laskenta", "lopullinen", "the"] myArray = myArray.reverse(); console.log(myArray); // ["loppulaskenta"]

On mahdollista lajitella taulukon elementtejä aakkosjärjestyksessä sort()-menetelmällä:

Var myArray = ["ksylofonit", "seeprat", "juggernauts", "avokadot"]; console.log(myArray); // ["ksylofonit", "seeprat", "juggernauts", "avokadot"] myArray = myArray.sort(); console.log(myArray); // ["avokadot", "juggernauts", "ksylofonit", "seeprat"]

Mutta tämä ei toimi numeroiden kanssa.

Var myArray = ; console.log(myArray); // myArray = myArray.sort(); console.log(myArray); //

Jos haluat lajitella numeroita, voit käyttää seuraavaa koodia:

Funktio vertaaNumbert(a, b) ( palauttaa a - b; ) var myArray = ; console.log(myArray); // omaArray = myArray.sort(vertaileNumeroita); console.log(myArray); //

Kuten yllä näkyy, kun sort(:iin) lisätään yksinkertainen funktio, numerot sisältävä taulukko lajitellaan oikein.

Taulukkojen yhdistäminen.

Voimme yhdistää 2 tai useampia taulukoita ja saada 1 taulukon, joka sisältää yhdistettyjen taulukoiden elementit. Tätä varten käytämme concat()-menetelmää:

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat(omaArray2); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myNewArray = myArray.concat("Chris Murphy", "Patrick Pentland"); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Array-jako.

Voimme luoda uuden taulukon, joka sisältää yhden tai useamman elementin olemassa olevasta taulukosta käyttämällä slice()-funktiota:

Var myArray = ["Laulu", "Basso", "Kitara", "Rummut", "Omenat", "appelsiinit"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Omenat", "appelsiinit"]

Slice()-menetelmässä on 1 tai 2 argumenttia. Jos 1 argumentti (indeksi) välitetään, uusi taulukko luodaan kaikista vanhan elementeistä alkaen tästä indeksistä. Jos 2 argumenttia välitetään, uusi taulukko luodaan elementeistä alkaen ensimmäisestä argumentista aina elementtiin, jonka indeksi välitetään toisessa parametrissa, ei sisällä viimeistä. Jotta se olisi selkeämpi, katsotaanpa alla olevaa koodia:

Var myArray = ["Laulu", "Basso", "Kitara", "Rummut", "Omenat", "appelsiinit"]; var myNewArray = myArray.slice(0, 4); console.log(myNewArray); // ["Laulu", "Basso", "Kitara", "Rummut"]

Elementtien korvaaminen taulukossa.

Käytämme splice()-funktiota elementtien poistamiseen taulukosta, mutta voimme myös korvata taulukon elementin uusilla elementeillä:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice(3, 1, "Scott Shriner"); // korvaa 1 elementti indeksillä 3 console.log(myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

Splice()-menetelmä palauttaa aina taulukon, joka sisältää poistetut elementit. Rivi 2 palauttaa 1 elementin "Brian Bell".

Johtopäätös

Näissä artikkeleissa kuvattiin menetelmiä JavaScript-taulukoiden kanssa työskentelyyn. MDN:ssä on joitain muita kohteita, joita en sisällyttänyt tähän viestiin. Ne toimivat vain IE9+:ssa, joten niistä ei välttämättä ole hyötyä.

Onko lisättävää? Tai tiedätkö mielenkiintoisen kirjaston, joka auttaa hallitsemaan taulukoita? Ole hyvä ja kommentoi!

Kuinka poistaa tietty elementti taulukosta JavaScriptissä? (20)

Minulla on joukko kokonaislukuja ja lisään siihen elementtejä .push()-menetelmällä.

Onko olemassa helppoa tapaa poistaa tietty elementti taulukosta? Vastaa jotain kuten array.remove(int); ,

minun pitäisi käyttää pohja JavaScript - ei mitään kehyksiä ei sallita.

ES6 ja ilman mutaatiota: (Oct 2016) const removeByIndex = (luettelo, indeksi) => [ ...list.slice(0, index), ...list.slice(index + 1) ];

RemoveByIndex(,1) //=>

Muokattu lokakuussa 2016

• Tee siitä yksinkertainen, intuitiivinen ja selkeä (https://en.wikipedia.org/wiki/Occam%27s_razor)
• Tee siitä muuttumaton (alkuperäinen matriisi pysyy muuttumattomana)
• Tee tämä tavallisilla JS-toiminnoilla, jos selaimesi ei tue niitä - käytä monitäyttöä

Tässä koodiesimerkissä käytän "array.filter(...)"-funktiota tarpeettomien elementtien poistamiseen taulukosta, tämä toiminto ei muuta alkuperäistä taulukkoa ja luo uuden, jos selaimesi ei tue tätä toimintoa (esimerkiksi IE ennen versiota 9 tai Firefox ennen versiota 1.5), harkitse Mozillan polyfill-suodattimen käyttöä.

Kohteen poistaminen (ECMA-262 Edition 5 koodi eli oldstyle JS) var value = 3 var arr = arr = arr.filter(function(item) ( return item !== value )) console.log(arr) // [ 1 , 2, 4, 5 ] Kohteen poistaminen (ES2015-koodi) let value = 3 let arr = arr = arr.filter(item => item !== value) console.log(arr) // [ 1, 2, 4 , 5 ]

TÄRKEÄÄ ES2015 "() => ()" -nuolifunktion syntaksia ei tueta IE:ssä ollenkaan, Chrome ennen versiota 45, Firefox ennen versiota 22, Safari ennen versiota 10. Jos haluat käyttää ES2015-syntaksia vanhemmissa selaimissa, voit käyttää BabelJS:ää

Useiden kohteiden poistaminen (ES2016-koodi)

Tämän menetelmän lisäetu on, että voit poistaa useita elementtejä

Olkoon forDeletion = anna arr = arr = arr.filter(item => !forDeletion.includes(item)) // !!! Lue alta array.includes(...) -tuesta !!! console.log(arr) // [ 1, 4 ]

TÄRKEÄÄ "array.includes(...)" ei ole tuettu IE:ssä ollenkaan, Chrome ennen versiota 47, Firefox ennen versiota 43, Safari ennen versiota 9 ja Edge ennen versiota 14, joten

Useiden elementtien poistaminen (Advanced Experimental JavaScript ES2018?) // array-lib.js-vientifunktio remove(...forDeletion) ( return this.filter(item => !forDeletion.includes(item)) ) // main.js tuonti ( poista ) tiedostosta "./array-lib.js" anna arr = // :: This-Binding Syntax Proposal // käyttämällä "remove"-toimintoa "virtuaalimenetelmänä" // laajentamatta Array.prototypeä arr = arr::remove (2, 3, 5) console.log(arr) // [ 1, 4 ]

Tässä on joitain tapoja poistaa elementti taulukosta JavaScriptin avulla.

Kaikki kuvatut menetelmät eivät muuta alkuperäistä taulukkoa, vaan luovat uuden.

Jos tiedät elementtiindeksin

Oletetaan, että sinulla on taulukko ja haluat poistaa elementin paikasta i .

Yksi tapa on käyttää slice():tä:

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

slice() luo uuden taulukon vastaanottamillaan indekseillä. Luomme yksinkertaisesti uuden taulukon - alusta poistettavaan hakemistoon ja ketjutamme toisen taulukon ensimmäisestä poistetun taulukon jälkeisestä sijainnista taulukon loppuun.

Jos tiedät merkityksen

Tässä tapauksessa yksi hyvä vaihtoehto on käyttää filter():tä, joka tarjoaa enemmän deklaratiivinen lähestyminen:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(tuote => kohde !== arvoPoista) console.log(filteredItems)

Tämä käyttää ES6-nuolitoimintoja. Voit käyttää perinteisiä toimintoja vanhempien selaimien tukemiseen:

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

tai voit käyttää Babelia ja muuntaa ES6-koodin takaisin ES5:ksi, jotta se olisi helpompi lukea vanhemmille selaimille, mutta kirjoita koodiisi moderni JavaScript.

Useiden kohteiden poistaminen

Entä jos yhden elementin sijaan haluat poistaa useita elementtejä?

Etsitään yksinkertaisin ratkaisu.

Indeksin mukaan

Voit luoda funktion ja poistaa elementtejä peräkkäin:

const items = ["a", "b", "c", "d", "e", "f"] const removeItem = (items, i) => items.slice(0, i-1).concat (items.slice(i, items.length)) anna filteredItems = removeItem(items, 3) filteredItems = removeItem(filteredItems, 5) //["a", "b", "c", "d"] konsoli. loki(suodatetut kohteet)

Arvon mukaan

Voit etsiä sisällyttämistä takaisinsoittotoiminnon sisältä:

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

Vältä alkuperäisen taulukon muuntamista

splice() (ei pidä sekoittaa slice()-funktioon) mutatoi alkuperäisen taulukon ja sitä tulee välttää.

Voit käyttää ES6:ta.

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

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

Voit tehdä tämän helposti suodatusmenetelmällä:

Funktio remove(arrOriginal, elementToRemove)( return arrOriginal.filter(function(el)(return el !== elementToRemove)); ) console.log(remove(, 1));

Tämä poistaa kaikki elementit taulukosta ja toimii myös nopeammin kuin slice- ja indexOf-yhdistelmä

Sinun ei pitäisi koskaan mutatoida taulukon taulukkoa. Koska se on vastoin toiminnallista ohjelmointimallia. Voit luoda uuden taulukon ilman viittausta taulukkoon, jota haluat muokata käyttämällä es6-menetelmäsuodatinta;

Var myArray = ;

Oletetaan, että haluat poistaa 5 taulukosta, voit tehdä sen näin.

OmaArray = myArray.filter(arvo => arvo !== 5);

Tämä antaa sinulle uuden taulukon ilman arvoa, jonka haluat poistaa. Tulos tulee siis olemaan

; // 5 on poistettu tästä taulukosta

Lisätietoa varten voit lukea Array.filter-suodattimen MDN-dokumentaatiosta

Jos haluat uuden taulukon, josta on poistettu paikat, voit aina poistaa tietyn elementin ja suodattaa taulukon. Saattaa olla tarpeen laajentaa taulukkoobjektia selaimille, jotka eivät käytä suodatusmenetelmää, mutta pitkällä aikavälillä se on helpompaa, koska teet vain tämän:

Muutt oma_taulukko = ; poista my_array; console.log(my_array.filter(function(a)(palautustyyppi a !== "määrittämätön";)));

Pitäisi näyttää

Jos taulukossa on monimutkaisia ​​objekteja, voitko käyttää suodattimia? Tilanteissa, joissa $.inArray tai array.splice eivät ole niin helppokäyttöisiä. Varsinkin jos objektit ovat ehkä pieniä taulukossa.

Jos sinulla on esimerkiksi objekti, jossa on Id-kenttä ja haluat, että objekti poistetaan taulukosta:

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

Etsi poistettavan taulukon elementin indeksi ja poista sitten kyseinen indeksi käyttämällä liitosta.

Splice()-menetelmä muokkaa taulukon sisältöä poistamalla olemassa olevia elementtejä ja/tai lisäämällä uusia elementtejä.

var array = ; console.log(array) var index = array.indexOf(5); if (indeksi > -1) ( array.splice(index, 1); ) // array = console.log(array);

Toinen liitettävä parametri on poistettavien elementtien määrä. Huomaa, että liitos muokkaa taulukkoa paikalleen ja palauttaa uuden taulukon, joka sisältää poistetut elementit.

Sinulla on 1–9 taulukkoa ja haluat poistaa 5 alla olevan koodin avulla.

var numberArray = ; var newNumberArray = numberArray.filter(m => (paluu m !== 5; )); console.log("uusi taulukko, 5 poistettu", newNumberArray);

Jos haluat käyttää useita ex-arvoja: - 1,7,8

var numberArray = ; var newNumberArray = numberArray.filter(m => ( paluu (m !== 1) && (m !== 7) && (m !== 8; )); console.log("uusi taulukko, 5 poistettu", newNumberArray);

Jos haluat poistaa taulukon arvon ex-taulukosta:-

var numberArray = ; var removebleArray = ; var newNumberArray = numberArray.filter(m => ( return !removebleArray.includes(m); )); console.log("uusi taulukko, poistettu", uusiNumberArray);

sisältää tuetun selaimen - linkki

Tiedän, että vastauksia on jo monia, mutta monet niistä näyttävät vaikeuttavan ongelmaa. Tässä on yksinkertainen, rekursiivinen tapa poistaa kaikki avaimen esiintymät – soita itsellesi, kunnes indeksi löytyy. Kyllä, se toimii vain selaimissa indexOf , mutta se on yksinkertainen ja se voidaan täyttää helposti.

Offline-toiminto

Funktio removeAll(taulukko, avain)( var index = array.indexOf(avain); if(indeksi === -1) return; array.splice(index, 1); removeAll(array,key); )

Prototyyppi menetelmä

Array.prototype.removeAll = funktio(avain)( var index = this.indexOf(avain); if(indeksi === -1) paluu; this.splice(index, 1); this.removeAll(avain); )

Array.prototype.removeItem = function(a) ( for (i = 0; i< this.length; i++) { if (this[i] == a) { for (i2 = i; i2 < this.length - 1; i2++) { this = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");

Kuinka poistaa elementti taulukosta arvon perusteella? (20)

// muokattu kiitos MarcoCI:lle neuvoista

Kokeile:

Funktio wantDelete(kohde, arr)( for (var i=0;i !(comment.Id === commentId));

Tässä on versio, joka käyttää jQueryn inArray-toimintoa:

Muutt indeksi = $.inArray(nimike, array); if (indeksi != -1) ( array.splice(indeksi, 1); )

Voit saavuttaa tämän käyttämällä Lodashin _.remove-toimintoa.

var array = ["kolme", ​​"seitsemän", "yksitoista"]; var evens = _.remove(array, function(e) ( return e !== "seitsemän"; )); console.log(evens);

Const _ = vaatia("lodash"); _.ilman(, 2); // ->

En todellakaan ymmärrä, miksi tätä ei voida ratkaista

Arr = arr.filter(arvo => arvo !== "seitsemän");

Tai ehkä haluat käyttää vanilja JS:ää

Arr = arr.filter(funktio(arvo) (palautusarvo !== "seitsemän" ));

Toinen variantti:

If (!Array.prototype.removeArr) ( Array.prototype.removeArr = function(arr) ( if(!Array.isArray(arr)) arr=;//olkaamme ystävällisiä ihmisille, jotka laittavat ei-taulukon arvon tässä.. se voisi olla minä var that = this; ) )

Tämä on indexOf() jälleen silmukan sisällä, mutta olettaen, että poistettava taulukko on pieni suhteessa poistettavaan taulukkoon; jokainen poisto lyhentää while-silmukkaa.

Näin voit tehdä seuraavat:

Var ary = ["kolme", ​​"seitsemän", "yksitoista"]; var aryWithoutSeven = ary.filter(funktio(arvo) (palautusarvo != "seitsemän" )); console.log(aryWithoutSeven); // palauttaa ["kolme", ​​"yksitoista"]

Tämä mainittiin myös tässä ketjussa muualla: https://.com/a/20827100/293492

Älä käytä poistovaihtoehtoa - se tekee taulukkoon reiän, koska se ei indeksoi elementtejä uudelleen poistetun elementin jälkeen.

> Array.prototype.remove=function(v)( ... poista tämä ... ); > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ "3", "24", "2" ]

Yksi laineri tekee sen,

Var ary = ["kolme", ​​"seitsemän", "yksitoista"]; // Poista kohde "seven" taulukosta var filteredAry = ary.filter(function(e) ( return e !== "seven" )) //=> ["kolme", ​​"yksitoista"] // ECMA6:ssa (nuoli funktion syntaksi): var filteredAry = ary.filter(e => e !== "seven")

Tämä käyttää JS:n suodatintoimintoa. Sitä tuetaan IE9:ssä ja uudemmissa.

filter() kutsuu tarjotun takaisinkutsun funktion kerran jokaiselle taulukon elementille ja luo uuden taulukon kaikista arvoista, joille takaisinkutsu palauttaa arvon, jonka arvo on tosi. takaisinkutsua kutsutaan vain taulukon indekseille, joille on määritetty arvoja; sitä ei vaadita indekseille, jotka on hylätty tai joille ei ole koskaan annettu arvoja. Takaisinsoittotestissä epäonnistuneet taulukkoelementit yksinkertaisesti ohitetaan, eikä niitä sisällytetä uuteen taulukkoon.

Eli periaatteessa se on sama kuin kaikki muut (var key in ary) ( ... ) -ratkaisuille, paitsi että for in on tuettu IE6:na.

Pohjimmiltaan suodatin on mukavuusmenetelmä, joka näyttää paljon mukavammalta (ja on ketjutettavissa) verrattuna for in konstruktoriin (AFAIK).

Tarkista se:

For(var i taulukossa)( if(array[i]=="seitsemän")( array.splice(i,1); break; ) )

ja funktiossa:

Funktio removeItem(array, item)( for(var i in array)( if(array[i]==item)( array.splice(i,1); break; ) ) ) removeItem(array, "seven");

Kaikkien vastaavien elementtien poistaminen taulukosta (ei vain ensimmäinen, kuten tässä näyttää olevan yleisin vastaus):

While ($.inArray(kohde, array) > -1) ( array.splice($.inArray(nimike, array), 1); )

Käytin jQueryä raskaiden nostoihin, mutta ymmärrät, jos haluat käyttää natiivia.

Temppu on käydä taulukko läpi alusta alusta, jotta et sotke indeksejä, kun poistat elementtejä.

Var deleteMe = function(arr, me)( var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); ) var arr = ["oranssi "," punainen", "musta", "oranssi", "valkoinen" , "oranssi" ]; deleteMe(arr, "oranssi");

arr on nyt ["punainen", "musta", "valkoinen"]

Funktio cleanArrayOfSpecificTerms(array,unwantedTermsArray) ( $.each(unwantedTermsArray, function(index, value)) (muut index = array.indexOf(arvo); if (indeksi > -1) ( array.splice(indeksi, 1); ) ) );

Käytä näitä ohjeita:

Var notInclude = ["Ei","Ei","Ensimmäinen","Viimeinen","Aiempi","Seuraava", "koirat","kissat"]; var splitTerms = ["puhelu", "loki", "koirat", "kissat", "aihe", "muutos", "hinnoittelu"]; cleanArrayOfSpecificTerms(splitTerms,notInclude)

Yritin käyttää yllä olevaa jbaronin funktiomenetelmää, mutta huomasin, että minun piti säilyttää alkuperäinen taulukko muuttumattomana myöhempää käyttöä varten ja luoda uusi taulukko seuraavasti:

Var newArray = viiteArray;

Funktio newArrRemoveItem(array, item, newArray)( for(var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Käytän sitä sitten näin:

Muut aluksenID = record.get("Aluksen ID"); var muutVessels = new Array(); newArrRemoveItem(alusArr,alusID,muut alukset);

Nyt shipArr pysyy ehjänä ja joka kerta kun suoritan yllä olevan koodin, otherVessels-taulukko sisältää kaiken paitsi viimeisen CAID-elementin.

indexOf on vaihtoehto, mutta sen toteutus etsii periaatteessa koko taulukosta arvoa, joten suoritusaika kasvaa taulukon koon mukaan. (Joten se on mielestäni jokaisessa selaimessa, tarkistin vain Firefoxin).

Minulla ei ole IE6:ta testattavana, mutta sanoisin varmaksi, että voit testata tällä tavalla vähintään miljoona taulukkoelementtiä sekunnissa melkein millä tahansa asiakaskoneella. Jos [taulukon koko] * [hakukyselyt sekunnissa] kasvaa todennäköisesti yli miljoonan, sinun tulee harkita erilaista toteutusta.

Periaatteessa voit käyttää objektia luodaksesi indeksin taulukkoosi, kuten näin:

Var index=("kolme":0, "seitsemän":1, "yksitoista":2);

Mikä tahansa normaali JavaScript-kehys luo hakuindeksin tällaisille objekteille, jotta voit muuntaa avaimen nopeasti arvoksi riippumatta siitä, kuinka monta ominaisuutta objektilla on.

Tämä on vain perusmenetelmä, tarpeidesi mukaan voit yhdistää useita objekteja ja/tai matriiseja tehdäksesi samoista tiedoista nopeasti haettavissa eri ominaisuuksia varten. Jos määrittelet erityistarpeesi, voin ehdottaa tarkempaa tietorakennetta.

//Tämän funktion avulla voit poistaa parillisen taulukon taulukosta var removeFromArr = function(arr, elem) ( var i, len = arr.length, new_arr = , sort_fn = funktio (a, b) ( return a - b; ); for (i = 0;< len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Käyttöesimerkki

Muutt arr = , "abc", 1, "1", 1]; poistaArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; poistaArr(arr, ); //]

Olkoon arr = ; console.log(arr); //tulos anna index = arr.indexOf(30); if (indeksi > -1) ( arr.splice(index, 1); ) console.log(arr); //tulos

Muutt indeksi = array.indexOf("tuote"); if(indeksi!=-1)( array.splice(indeksi, 1); )

poista tietty js-taulukkoelementti (20)

Onko olemassa tapaa poistaa elementti JavaScript-taulukosta?

Annettu taulukko:

Var ary = ["kolme", ​​"seitsemän", "yksitoista"];

Haluaisin tehdä jotain tällaista:

RemoveItem("seven", ary);

Katsoin splice():tä, mutta se poistaa vain paikan numeron, kun taas tarvitsen jotain elementin poistamiseksi sen arvon perusteella.

// muokattu kiitos MarcoCI:lle neuvoista

Kokeile:

Funktio wantDelete(kohde, arr)( for (var i=0;i !(comment.Id === commentId));

Tässä on versio, joka käyttää jQueryn inArray-toimintoa:

Muutt indeksi = $.inArray(nimike, array); if (indeksi != -1) ( array.splice(indeksi, 1); )

Voit saavuttaa tämän käyttämällä Lodashin _.remove-toimintoa.

var array = ["kolme", ​​"seitsemän", "yksitoista"]; var evens = _.remove(array, function(e) ( return e !== "seitsemän"; )); console.log(evens);

Const _ = vaatia("lodash"); _.ilman(, 2); // ->

En todellakaan ymmärrä, miksi tätä ei voida ratkaista

Arr = arr.filter(arvo => arvo !== "seitsemän");

Tai ehkä haluat käyttää vanilja JS:ää

Arr = arr.filter(funktio(arvo) (palautusarvo !== "seitsemän" ));

Toinen variantti:

If (!Array.prototype.removeArr) ( Array.prototype.removeArr = function(arr) ( if(!Array.isArray(arr)) arr=;//olkaamme ystävällisiä ihmisille, jotka laittavat ei-taulukon arvon tässä.. se voisi olla minä var that = this; ) )

Tämä on indexOf() jälleen silmukan sisällä, mutta olettaen, että poistettava taulukko on pieni suhteessa poistettavaan taulukkoon; jokainen poisto lyhentää while-silmukkaa.

Näin voit tehdä seuraavat:

Var ary = ["kolme", ​​"seitsemän", "yksitoista"]; var aryWithoutSeven = ary.filter(funktio(arvo) (palautusarvo != "seitsemän" )); console.log(aryWithoutSeven); // palauttaa ["kolme", ​​"yksitoista"]

Tämä mainittiin myös tässä ketjussa muualla: https://.com/a/20827100/293492

Älä käytä poistovaihtoehtoa - se tekee taulukkoon reiän, koska se ei indeksoi elementtejä uudelleen poistetun elementin jälkeen.

> Array.prototype.remove=function(v)( ... poista tämä ... ); > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ "3", "24", "2" ]

Yksi laineri tekee sen,

Var ary = ["kolme", ​​"seitsemän", "yksitoista"]; // Poista kohde "seven" taulukosta var filteredAry = ary.filter(function(e) ( return e !== "seven" )) //=> ["kolme", ​​"yksitoista"] // ECMA6:ssa (nuoli funktion syntaksi): var filteredAry = ary.filter(e => e !== "seven")

Tämä käyttää JS:n suodatintoimintoa. Sitä tuetaan IE9:ssä ja uudemmissa.

filter() kutsuu tarjotun takaisinkutsun funktion kerran jokaiselle taulukon elementille ja luo uuden taulukon kaikista arvoista, joille takaisinkutsu palauttaa arvon, jonka arvo on tosi. takaisinkutsua kutsutaan vain taulukon indekseille, joille on määritetty arvoja; sitä ei vaadita indekseille, jotka on hylätty tai joille ei ole koskaan annettu arvoja. Takaisinsoittotestissä epäonnistuneet taulukkoelementit yksinkertaisesti ohitetaan, eikä niitä sisällytetä uuteen taulukkoon.

Eli periaatteessa se on sama kuin kaikki muut (var key in ary) ( ... ) -ratkaisuille, paitsi että for in on tuettu IE6:na.

Pohjimmiltaan suodatin on mukavuusmenetelmä, joka näyttää paljon mukavammalta (ja on ketjutettavissa) verrattuna for in konstruktoriin (AFAIK).

Tarkista se:

For(var i taulukossa)( if(array[i]=="seitsemän")( array.splice(i,1); break; ) )

ja funktiossa:

Funktio removeItem(array, item)( for(var i in array)( if(array[i]==item)( array.splice(i,1); break; ) ) ) removeItem(array, "seven");

Kaikkien vastaavien elementtien poistaminen taulukosta (ei vain ensimmäinen, kuten tässä näyttää olevan yleisin vastaus):

While ($.inArray(kohde, array) > -1) ( array.splice($.inArray(nimike, array), 1); )

Käytin jQueryä raskaiden nostoihin, mutta ymmärrät, jos haluat käyttää natiivia.

Temppu on käydä taulukko läpi alusta alusta, jotta et sotke indeksejä, kun poistat elementtejä.

Var deleteMe = function(arr, me)( var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); ) var arr = ["oranssi "," punainen", "musta", "oranssi", "valkoinen" , "oranssi" ]; deleteMe(arr, "oranssi");

arr on nyt ["punainen", "musta", "valkoinen"]

Funktio cleanArrayOfSpecificTerms(array,unwantedTermsArray) ( $.each(unwantedTermsArray, function(index, value)) (muut index = array.indexOf(arvo); if (indeksi > -1) ( array.splice(indeksi, 1); ) ) );

Käytä näitä ohjeita:

Var notInclude = ["Ei","Ei","Ensimmäinen","Viimeinen","Aiempi","Seuraava", "koirat","kissat"]; var splitTerms = ["puhelu", "loki", "koirat", "kissat", "aihe", "muutos", "hinnoittelu"]; cleanArrayOfSpecificTerms(splitTerms,notInclude)

Yritin käyttää yllä olevaa jbaronin funktiomenetelmää, mutta huomasin, että minun piti säilyttää alkuperäinen taulukko muuttumattomana myöhempää käyttöä varten ja luoda uusi taulukko seuraavasti:

Var newArray = viiteArray;

Funktio newArrRemoveItem(array, item, newArray)( for(var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Käytän sitä sitten näin:

Muut aluksenID = record.get("Aluksen ID"); var muutVessels = new Array(); newArrRemoveItem(alusArr,alusID,muut alukset);

Nyt shipArr pysyy ehjänä ja joka kerta kun suoritan yllä olevan koodin, otherVessels-taulukko sisältää kaiken paitsi viimeisen CAID-elementin.

indexOf on vaihtoehto, mutta sen toteutus etsii periaatteessa koko taulukosta arvoa, joten suoritusaika kasvaa taulukon koon mukaan. (Joten se on mielestäni jokaisessa selaimessa, tarkistin vain Firefoxin).

Minulla ei ole IE6:ta testattavana, mutta sanoisin varmaksi, että voit testata tällä tavalla vähintään miljoona taulukkoelementtiä sekunnissa melkein millä tahansa asiakaskoneella. Jos [taulukon koko] * [hakukyselyt sekunnissa] kasvaa todennäköisesti yli miljoonan, sinun tulee harkita erilaista toteutusta.

Periaatteessa voit käyttää objektia luodaksesi indeksin taulukkoosi, kuten näin:

Var index=("kolme":0, "seitsemän":1, "yksitoista":2);

Mikä tahansa normaali JavaScript-kehys luo hakuindeksin tällaisille objekteille, jotta voit muuntaa avaimen nopeasti arvoksi riippumatta siitä, kuinka monta ominaisuutta objektilla on.

Tämä on vain perusmenetelmä, tarpeidesi mukaan voit yhdistää useita objekteja ja/tai matriiseja tehdäksesi samoista tiedoista nopeasti haettavissa eri ominaisuuksia varten. Jos määrittelet erityistarpeesi, voin ehdottaa tarkempaa tietorakennetta.

//Tämän funktion avulla voit poistaa parillisen taulukon taulukosta var removeFromArr = function(arr, elem) ( var i, len = arr.length, new_arr = , sort_fn = funktio (a, b) ( return a - b; ); for (i = 0;< len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Käyttöesimerkki

Muutt arr = , "abc", 1, "1", 1]; poistaArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; poistaArr(arr, ); //]

Olkoon arr = ; console.log(arr); //tulos anna index = arr.indexOf(30); if (indeksi > -1) ( arr.splice(index, 1); ) console.log(arr); //tulos

Muutt indeksi = array.indexOf("tuote"); if(indeksi!=-1)( array.splice(indeksi, 1); )

JavaScriptissä on useita tapoja poistaa taulukkoelementti. Näitä ovat pop- ja shift-menetelmät. Pop-menetelmä poistaa ensimmäisen elementin annetusta taulukosta. Siirtomenetelmä poistaa viimeisen elementin annetusta taulukosta.

Voit asettaa taulukon pituudeksi 0, jos haluat poistaa kaikki elementit annetusta taulukosta. Mutta mitä, pitääkö tietty elementti poistaa?

Esimerkiksi:

Array_name.splice(indeksi);

Array_name.delete

Voit käyttää liitosmenetelmää. Se palauttaa uuden joukon poistettuja elementtejä. Ja alkuperäinen matriisi sisältää loput elementit.

Tutustu alla olevaan esittelyyn oppiaksesi käyttämään JavaScript-liitosmenetelmää ja muita tapoja poistaa tiettyjä elementtejä.

Esittely tietyn elementin poistamisesta liitosmenetelmällä

Tämä demo luo joukon numeroita. Aluksi taulukkoon lisätään viisi elementtiä. Tämän jälkeen käytetään liitosmenetelmää kolmannen elementin poistamiseen. Samalla tavalla voit poistaa taulukon ensimmäisen elementin JavaScriptissä.

Numeerisen taulukon elementit näytetään ennen ja jälkeen JavaScript-liitosmenetelmän käytön seuraavasti:

JavaScript-koodi liitosmenetelmällä:

"; for (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2,1); var the_arr_before_after = "Matriisielementit liitosmenetelmän jälkeen:
"; for (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "

Huomaat, että käytin kahta JavaScript-parametria taulukkoelementin poistamiseen. Ensimmäinen määrittää poistettavan elementin indeksin. Toinen on se, kuinka monta elementtiä on poistettava määritetyn avaimen jälkeen.

Seuraava esittely näyttää tapauksen, jossa käytämme toista parametria.

Entä jos toista parametria ei ole määritetty JavaScript-liitosmenetelmässä?

Käyttämällä samaa koodia, mutta ilman liitosmenetelmän toista parametria:

Arr_Numbers.splice(2);

Koodi ja tulos:

Katso online-demo ja koodi

Kuten näet, kaikki elementit ennen määritettyä indeksinumeroa on myös poistettu. Lisäksi liitosmenetelmä palauttaa joukon poistettuja elementtejä.

JavaScript-koodi:

var Arr_Numerot = ; var i; var the_arr_before_after = "Alkuperäinen taulukko:
"; for (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2); var the_arr_before_after = "Matriisielementit liitosmenetelmän jälkeen:
"; for (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_before_after; //Poistetut taulukkoelementit palautetusta taulukosta var the_arr_before_after = "Poistetut taulukkoelementit:
"; for (i=0; i< Arrretrun.length; i++){ the_arr_before_after += Arrretrun[i] + "
"; ) document.getElementById("p3").innerHTML = the_arr_fore_after;

Poista-funktion käyttäminen taulukkoelementin poistamiseen

Voit myös poistaa JavaScriptin taulukkoelementin poistamistoiminnolla. Mutta se säästää tyhjää tilaa, ja jos palautat kyseisen taulukon funktion käytön jälkeen, poistettu elementti hahmonnetaan määrittelemättömänä .

Katsotaanpa demoa, joka käyttää poistotoimintoa:

Katso online-demo ja koodi

JavaScript-koodi:

var Arr_Strings = ["The","JavaScript","Matriisi","Totorial"]; var i; var the_arr_before_after = "Alkuperäiset merkkijonotaulukon elementit:

"; for (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; //Delete-funktiolla delete Arr_Strings; var the_arr_before_after = "Matriisielementit liitosmenetelmän jälkeen:

"; for (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_fore_after;

Voit nähdä, että kolmas elementti näkyy määrittelemättömänä sen jälkeen, kun se on poistettu poistotoiminnolla.