Hogyan távolíthatok el egy adott elemet egy tömbből a JavaScriptben? (húsz)

Van egy egész számom, és a .push () metódust használom elemek hozzáadásához.

Van -e egyszerű módja annak, hogy egy adott elemet eltávolítsunk a tömbből? Valamivel egyenlő a tömb.remove (int); ,

Használnom kell bázis JavaScript - egyik sem keretek nem megengedettek.

ES6 és No Mutation: (2016. október)

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

RemoveByIndex (, 1) // =>

Szerkesztve: 2016 október

• Legyen egyszerű, intuitív és nyílt (https://en.wikipedia.org/wiki/Occam%27s_razor)
• Változtassa meg (az eredeti tömb változatlan marad)
• Ha a böngészője nem támogatja ezeket, tegye a szokásos JS funkciókkal - használjon polyfill -et

Ebben a példakódban én használom függvény tömb.szűrő (...) " a felesleges elemek eltávolításához a tömbből ez a függvény nem változtatja meg az eredeti tömböt, és újat hoz létre. Ha a böngészője nem támogatja ezt a funkciót (pl. IE a 9 -es verzió előtt vagy a Firefox az 1,5 -ös verzió előtt), fontolja meg a használatát polifill szűrő a Mozilla -tól .

Elem eltávolítása (ECMA-262 Edition 5 kód, más néven oldstyle JS)

var érték = 3 var arr = arr = arr.filter (function (item) (return item! == value)) console.log (arr) // [1, 2, 4, 5]

Elem törlése (ES2015 kód)

let value = 3 let arr = arr = arr.filter (item => item! == value) console.log (arr) // [1, 2, 4, 5]

FONTOS Az ES2015 "() => ()" nyílfüggvény szintaxis egyáltalán nem támogatott az IE -ben, a Chrome a 45 -ös verzió előtt, a Firefox a 22 -es verzió előtt, a Safari a 10 -es verzió előtt. Az ES2015 szintaxisának használatához a régebbi böngészőkben használhatja a BabelJS -t

Több elem eltávolítása (ES2016 kód)

A módszer további előnye, hogy több elemet is eltávolíthat

Legyen forDeletion = hagyja arr = arr = arr.filter (item =>! ForDeletion.includes (item)) // !!! Olvassa el alább a tömböt. Magában foglalja a (...) támogatást !!! console.log (arr) // [1, 4]

FONTOS A "array.includes (...)" az IE -ben egyáltalán nem támogatott, a Chrome a 47 -es verzió előtt, a Firefox a 43 -as verzió előtt, a Safari a 9 -es verzió előtt és az Edge a 14 -es verzió előtt, tehát

Több elem eltávolítása (speciális kísérleti JavaScript ES2018?)

// array-lib.js export függvény remove (... forDeletion) (return this.filter (item =>! forDeletion.includes (item))) // main.js import (remove) innen: "./array-lib .js "let arr = // :: Ez a kötő szintaktikai javaslat // az" remove "függvény használata" virtuális módszerként "// Array.prototype kiterjesztése nélkül arr = arr :: remove (2, 3, 5) console.log (arr) // [1, 4]

Íme néhány módszer Javascript használatával távolítsa el az elemet a tömbből .

Az összes leírt módszer ne módosítsa az eredeti tömbötés ehelyett hozzon létre egy újat.

Ha ismeri az elem indexét

Tegyük fel, hogy van tömbje, és el szeretné távolítani az elemet az i pozícióból.

Az egyik módszer a szelet () használata:

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

A szelet () új tömböt hoz létre a kapott indexekkel. Egyszerűen létrehozunk egy új tömböt - az elejétől az eltávolítani kívánt indexig, és összefűzünk egy másik tömböt az első pozícióból, amelyet eltávolítottunk a tömb végéig.

Ha tudod a jelentését

Ebben az esetben az egyik jó lehetőség a filter () használata, amely többet kínál kijelentő megközelítés:

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

Ez ES6 nyílfüggvényeket használ. A hagyományos funkciókat használhatja a régebbi böngészők támogatására:

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

vagy használhatja a Bábelt, és konvertálhatja vissza ES6 kódját ES5 -re, hogy könnyebben emészthető legyen a régebbi böngészők számára, de írjon modern JavaScriptet a kódba.

Több elem eltávolítása

Mi van, ha egy elem helyett több elemet szeretne törölni?

Keressük a legegyszerűbb megoldást.

Index szerint

Egyszerűen létrehozhat egy funkciót, és egymás után eltávolíthatja az elemeket:

const item = ["a", "b", "c", "d", "e", "f"] const removeItem = (tételek, 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"] konzol. napló (szűrt elemek)

Érték szerint

A visszahívási funkcióban megtalálhatja a felvételt:

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

Kerülje az eredeti tömb mutálását

splice () (nem tévesztendő össze a szelet ()) mutálja az eredeti tömböt, és el kell kerülni.

Használhatja az ES6 -ot.

Var tömb = ["1", "2", "3", "4", "5", "6"] var index = tömb.szűrő ((érték) => érték! = "3");

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

Ezt egyszerűen elvégezheti a szűrési módszerrel:

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

Ez eltávolítja az összes elemet a tömbből, és gyorsabb is, mint a szelet és indexOf kombináció

Soha ne mutáljon tömb tömböt. Mivel ez ellentétes a funkcionális programozási mintával. Új tömböt hozhat létre anélkül, hogy hivatkozna a módosítani kívánt tömbre az es6 metódusszűrő használatával;

Var myArray =;

Tegyük fel, hogy el akar távolítani 5 -öt egy tömbből, ezt egyszerűen megteheti.

MyArray = myArray.filter (érték => érték! == 5);

Ezzel új tömböt kap a törölni kívánt érték nélkül. Tehát az eredmény lesz

; // 5 eltávolítva ebből a tömbből

További megértés érdekében olvassa el az MDN dokumentációját az Array.filter szűrőn

Ha azt szeretné, hogy az új tömb eltávolítsa a pozíciókat, akkor mindig eltávolíthat egy adott elemet, és szűrheti a tömböt. Előfordulhat, hogy ki kell bővítenie a tömbobjektumot azoknak a böngészőknek, amelyek nem valósítják meg a szűrési módszert, de hosszú távon könnyebb, mivel csak ezt kell tennie:

Var my_array =; törölje a_tömbömet; console.log (my_array.filter (function (a) (return typeof a! == "undefined";)));

Meg kell jeleníteni

Ha összetett objektumok vannak egy tömbben, használhat szűrőket? Olyan helyzetekben, amikor a $ .inArray vagy array.splice használata nem olyan egyszerű. Különösen akkor, ha az objektumok valószínűleg kicsik a tömbben.

Például, ha van egy azonosító mezővel rendelkező objektuma, és szeretné, hogy az objektum eltávolításra kerüljön a tömbből:

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

Keresse meg az eltávolítani kívánt tömb elem indexét, majd távolítsa el azt az összeillesztéssel.

A splice () módszer a meglévő elemek eltávolításával és / vagy új elemek hozzáadásával módosítja a tömb tartalmát.

var tömb =; console.log (tömb) var index = tömb.indexOf (5); if (index> -1) (tömb.spice (index, 1);) // tömb = konzol.napló (tömb);

A második összeillesztési paraméter az eltávolítandó elemek száma. Vegye figyelembe, hogy a splice módosítja a tömböt a helyén, és új tömböt ad vissza, amely tartalmazza az eltávolított elemeket.

1-9 tömbje van, és 5 -öt törölni szeretne az alábbi kód használatával.

var numberArray =; var newNumberArray = számArray.filter (m => (return m! == 5;)); console.log ("új tömb, 5 eltávolítva", newNumberArray);

Ha több ex értéket szeretne használni: - 1,7,8

var numberArray =; var newNumberArray = számArray.filter (m => (return (m! == 1) && (m! == 7) && (m! == 8);)); console.log ("új tömb, 5 eltávolítva", newNumberArray);

Ha törölni szeretne egy tömbértéket az ex tömbből: -

var numberArray =; var removebleArray =; var newNumberArray = számArray.filter (m => (return! removebleArray. magában foglalja (m);)); console.log ("új tömb, eltávolítva", newNumberArray);

tartalmaz egy támogatott böngésző linket

Tudom, hogy már sok válasz létezik, de úgy tűnik, hogy sok közülük bonyolítja a problémát. Íme egy egyszerű, rekurzív módszer a kulcs minden példányának törlésére - hívja magát, amíg meg nem találja az indexet. Igen, csak az indexOf böngészőkben működik, de egyszerű és könnyen feltölthető.

Önálló funkció

Funkció removeAll (tömb, kulcs) (var index = array.indexOf (kulcs); if (index === -1) return; array.splice (index, 1); removeAll (tömb, kulcs);)

Prototípus módszer

Array.prototype.removeAll = függvény (kulcs) (var index = this.indexOf (kulcs); if (index === -1) visszatér; this.splice (index, 1); this.removeAll (kulcs);)

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");

Hogyan lehet eltávolítani egy elemet egy tömbből érték szerint? (húsz)

// szerkesztve, köszönöm a MarcoCI tanácsát

próbáld ezt:

Function WantDelete (item, arr) (for (var i = 0; i

remélem ez segít

Van -e mód az elem eltávolítására a JavaScript tömbből?

Tekintettel a tömbre:

Var ary = ["három", "hét", "tizenegy"];

Valami ilyesmit szeretnék csinálni:

RemoveItem ("hét", ary);

Megnéztem a splice -t (), de ez csak a pozíció számát távolítja el, míg szükségem van valamire az elemek érték szerinti eltávolításához.

Hagyja, hogy commentsWithoutDeletedArray = commentsArray.filter ((megjegyzés) =>!

Íme egy verzió, amely a jQuery inArray függvényét használja:

Var index = $ .inArray (tétel, tömb); if (index! = -1) (array.splice (index, 1);)

Ezt a funkció használatával érheti el Lodash _. eltávolítás.

var array = ["három", "hét", "tizenegy"]; var evens = _.remove (tömb, függvény (e) (return e! == "seven";)); console.log (páros);

Const _ = igényel ("lodash"); _. (, 2) nélkül; // ->

Valóban, nem értem, miért nem lehet ezt megoldani

Arr = arr.filter (érték => érték! == "hét");

Vagy talán vaníliás JS -t szeretne használni

Arr = arr.filter (függvény (érték) (visszatérési érték! == "hét"));

Egy másik változat:

If (! Array.prototype.removeArr) (Array.prototype.removeArr = function (arr) (if (! Array.isArray (arr)) arr =; // legyünk kedvesek azokkal, akik nem tömb értéket adnak itt lehetnék én! var that = this; if (arr.length) (var i = 0; while (i -1) (ez.szelet (i, 1);) egyébként i ++; )) adja vissza; ))

Ez ismét indexOf () a cikluson belül, de feltételezve, hogy a törlendő tömb kicsi a tisztítandó tömbhöz képest; minden eltávolítás lerövidíti a while hurkot.

Ez lehetővé teszi a következők elvégzését:

Var ary = ["három", "hét", "tizenegy"]; var aryWithoutSeven = ary.filter (függvény (érték) (visszatérési érték! = "hét")); console.log (aryWithoutSeven); // visszaadja ["három", "tizenegy"]

Ezt már máshol is megjegyezték ebben a szálban: https: //.com/a/20827100/293492

Ne használja a törlés opciót - lyukat képez a tömbben, mivel nem törli újra az indexeket a törölt elem után.

> Array.prototype.remove = function (v) (... ezt törölni ...); > var myarray = ["3", "24", "55", "2"]; undefined> myarray.remove ("55"); undefined> myarray ["3", "24", "2"]

Egy bélés megcsinálja

Var ary = ["három", "hét", "tizenegy"]; // A "hét" elem eltávolítása a var filterből álló tömbből függvény szintaxisa): var filteredAry = ary.filter (e => e! == "seven")

Ez a JS szűrőfunkcióját használja. Támogatott az IE9 és újabb verziókban.

A filter () egyszer meghívja a megadott visszahívási függvényt a tömb minden egyes eleméhez, és létrehoz egy új tömböt azokból az értékekből, amelyekre a visszahívás igaz értéket ad vissza. a visszahívást csak azokhoz a tömbindexekhez hívják, amelyekhez értékeket rendeltek; nincs szükség olyan indexekre, amelyeket elejtettek, vagy amelyekhez soha nem rendeltek hozzá értékeket. A visszahívási teszten sikertelen tömb elemek egyszerűen kihagyásra kerülnek, és nem szerepelnek az új tömbben.

Tehát alapvetően ugyanaz, mint az összes többi (var key in ary) (...) megoldások, kivéve, hogy az in -t IE6 támogatja.

A szűrő alapvetően egy kényelmi módszer, amely sokkal jobban néz ki (és láncos), szemben a for in konstruktorral (AFAIK).

Ellenőrizd:

For (var i in array) (if (array [i] == "seven") (array.splice (i, 1); break;))

és a függvényben:

Funkció removeItem (tömb, tétel) (for (var i in array) (if (array [i] == item) (array.splice (i, 1); break;))) removeItem (tömb, "hét");

Az összes illeszkedő elem eltávolítása a tömbből (nem csak az első tűnik a legáltalánosabb válasznak):

Míg ($ .inArray (tétel, tömb)> -1) (array.splice ($. InArray (tétel, tömb), 1);)

Kemény munkához használtam a jQuery -t, de megérti, ha anyanyelvre szeretne menni.

A trükk az, hogy az elejétől az elejéig végigmegy a tömbön, így nem rontja el az indexeket az elemek törlésekor.

Var deleteMe = függvény (arr, me) (var i = arr.length; while (i--) if (arr [i] === me) arr.splice (i, 1);) var arr = ["narancs "," piros "," fekete "," narancs "," fehér "," narancs "]; deleteMe (arr, "narancs");

arr most már ["piros", "fekete", "fehér"]

Funkció cleanArrayOfSpecificTerms (tömb, nem kívántTermsArray) ($ .each (unsantedTermsArray, function (index, value) (var index = array.indexOf (value); if (index> -1) (array.splice (index, 1);)) ); visszatérési tömb;)

Használatához kövesse az alábbi lépéseket:

Var notInclude = ["Nem", "Nem", "Első", "Utolsó", "Előző", "Következő", "kutyák", "macskák"]; var splitTerms = ["call", "log", "kutyák", "macskák", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms (splitTerms, notInclude)

Próbáltam használni a fenti jbaron függvénymetódust, de azt találtam, hogy az eredeti tömböt változatlanul kell tartanom a későbbi használatra, és létre kell hoznom egy új tömböt, mint ez:

Var newArray = referenceArray;

Funkció newArrRemoveItem (tömb, tétel, newArray) (for (var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Akkor így használom:

Var shipID = rekord.get ("VesselID"); var otherVessels = new Array (); newArrRemoveItem (edényArr, edényazonosító, egyéb hajók);

Most a shipArr változatlan marad, és minden alkalommal, amikor végrehajtom a fenti kódot, a otherVessels tömb mindent tartalmaz, kivéve az utolsó CAID elemet.

Az indexOf opció, de megvalósítása alapvetően a teljes tömbben keres értéket, így a futási idő a tömb méretével együtt növekszik. (így van ez minden böngészőben, azt hiszem, csak a Firefoxot teszteltem).

Nincs IE6 ellenőrzésem, de biztos fogadásnak nevezném, hogy másodpercenként legalább egymillió tömb elemet ellenőrizhet szinte minden ügyfélgépen. Ha a [tömbméret] * [másodpercenként történő keresés] millió fölé nőhet, akkor fontolja meg egy másik megvalósítást.

Alapvetően használhat egy objektumot index létrehozásához a tömbhöz, például:

Var index = ("három": 0, "hét": 1, "tizenegy": 2);

Bármely normál JavaScript keretrendszer létrehoz egy keresési indexet az ilyen objektumokhoz, így gyorsan le tudja fordítani a kulcsot egy értékre, függetlenül attól, hogy az objektum hány tulajdonsággal rendelkezik.

Ez csak egy alapvető módszer, szükségleteitől függően több objektumot és / vagy tömböt kombinálhat, hogy ugyanazok az adatok gyorsan kereshetők legyenek a különböző tulajdonságok között. Ha megadja sajátos igényeit, javasolni tudok egy konkrétabb adatstruktúrát.

// Ez a függvény lehetővé teszi páros tömb eltávolítását a tömbből var removeFromArr = function (arr, elem) (var i, len = arr.length, new_arr =, sort_fn = function (a, b) (return a - b;); for ( i = 0; i< 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; }

Használati példa

Var arr =, "abc", 1, "1", 1]; removeFromArr (arr, 1); // ["2" ,, "abc", "1"] var arr = [, 2, "a" ,,]; removeFromArr (arr,); //]

Legyen arr =; console.log (arr); // eredmény legyen index = arr.indexOf (30); if (index> -1) (arr.splice (index, 1);) console.log (arr); // eredmény

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

váltás

A .shift használatával távolítsa el a tömb első elemét.

Például:

Var tömb =; array.shift ();

tömb eredménye:

Például:

Var tömb =; array.pop ();

tömb eredménye:

Mindkét módszer visszaadja az eltávolított elemet;

összeillesztés

A.splice () használatával távolítsa el az elemek sorozatát a tömbből. A .splice () két paramétert, egy kezdőindexet és egy opcionális kardinalitást igényel eltávolítani. Ha a második paraméter nem, a splice () minden elemet eltávolít a kezdő indexből a tömb végéig.

Például:

Var tömb =; tömb.szelet (1, 2);

tömböt hagy, amely tartalmazza:

A tömb.splice () visszatérése egy új tömb, amely tartalmazza az eltávolított elemeket. A fenti példában a visszatérés a következő lenne:

Így a második paraméter kihagyása hatékonyan felosztja a tömböt két tömbre, az eredeti végződéssel a megadott indexig:

Var tömb =; tömb.szelet (2);

Elhagy egy tömböt, amely tartalmazza és visszatér.

töröl

A Delete használatával távolítson el egy elemet a tömbből a tömb hosszának megváltoztatása nélkül:

Var tömb =; console.log (tömb.hossz); // 5 tömb törlése; console.log (tömb); // console.log (tömb.hossz); 5

Tömb.prototípus.hossz

Az érték hozzárendelése a tömb hosszához megváltoztatja a hosszúságot a megadott értékkel. Ha az új érték kisebb, mint a tömb hossza, az elemek eltávolításra kerülnek az érték végéről.

Tömb =; tömb.hossz = 2; console.log (tömb); //

A tömbökkel való munka módszereinek csak egy részét írtam le.

Itt a tömb elemek hozzáadásáról, eltávolításáról fogunk beszélni. Egy tömb megfordításáról és rendezéséről, valamint tömbök szeleteléséről, cseréjéről és kombinálásáról.

Elemek hozzáadása tömbhöz.

A length tulajdonsággal új elemeket adhat hozzá a tömbhöz:

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

Ez működni fog, mert tömb elemei számozva vannak nullától, és hossz még egy. Hossz mindig egyenértékű index + 1így nagyon könnyű új elemet hozzáadni a tömb végéhez. Furcsa, de hozzáadhat egy elemet olyan helyre, amely sokkal nagyobb, mint maga a tömb hossza:

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

Amint azt a megjegyzések mutatják, 95 üres hely és egy "Lindsey Buckingham" elem kerül a tömb végére. Ezt követően megkapjuk a 100 hosszúságot. Egy másik módja annak, hogy új elemet adjunk hozzá a tömbhöz, a módszer használata nyom ():

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

Módszer nyom () mindig a tömb új hosszát adja vissza (esetünkben 5). A segítségével hozzáadhat egy elemet összeillesztés ():

Var myArray = ["makk", "bükk", "mongongo", "makadámia"]; myArray.slic (2, 0, "kesudió"); // "kesudiót" ad hozzá a 2. indexhez console.log (myArray); // ["makk", "bükk", "kesudió", "mongongo", "makadámia"]

Ha a második argumentum 0, ez azt jelenti, hogy egyetlen elem sem kerül eltávolításra, és ezért minden további argumentum hozzá lesz adva a tömbhöz az első argumentumban megadott helyen.

Elemek eltávolítása tömbből

Egy elem eltávolítása kicsit nehezebb, mint hozzáadása. Egy elem eltávolításához a tömb végéről használhatja pop ():

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

Módszer pop () mindig eltávolítja a tömb utolsó elemét, és visszaadja.

Ön is használhatja összeillesztés () módszer:

Var myArray = ["manióka", "szerecsendió", "csillagfürt", "rebarbara"]; myArray.slic (2, 1); // elem eltávolítása a 2. indexből console.log (myArray); // ["manióka", "szerecsendió", "rebarbara"]

Ellentétben a módszerrel összeillesztés (), amely elemek hozzáadására szolgál, itt a második argumentum az 1, amely azt mondja, hogy el akarjuk távolítani az elemet a 2 -es indexszel (vagy a 3. sorban). Ebben az esetben a "csillagfürt" elemet eltávolították.

A tömb elemeit az operátor segítségével távolíthatja el töröl:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log (myArray.length); // 4 myArray törlése; // Eliza eltávolítása console.log (myArray.length); // 4 console.log (myArray); // ["Byte Bandit", undefined × 1, "Jeefo", "Michelangelo"]

Első fontos megjegyzés: törlés () nem változtatja meg a tömb hosszát az elem eltávolítása után (még akkor sem, ha ez volt a tömb utolsó eleme). Második: törlés () az eltávolított elem értékét definiálatlanra változtatja, tehát tolatáskor myArray = nem definiált.

Az elemek tömbből való eltávolításának jó módja John Resig Array.remove használata. Az alábbiakban egy példát mutatunk be az oldaláról:

// Tömb eltávolítása - John Resig (MIT licenc) Array.prototype.remove = function (from, to) (var rest = this.slice ((to || from) + 1 || this.length); this.length = tól< 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);

Érdemes megnézni a Viral Patel megoldását, az Underscore.js egyik funkcióját vagy a jQuery grep () parancsát.

Ezenkívül ben JavaScript van egy módszer shift (), amely eltávolítja a tömb első elemét és visszaadja annak értékét. Nézzük a kódot:

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

A módszer használata műszak () eltávolítottuk az elemet, de elmentettük értékét az firstItem változónkba. A tömb hossza 4 -ről 3 -ra változott.

Ez a módszer a módszerrel együtt hasznos lehet nyom (). Ha együtt használjuk őket, hatékonyan sorba állíthatjuk a tömb elemeit. Megtartjuk a tömb hosszát úgy, hogy eltávolítjuk az elemet az elejéről, és újat adunk a végéhez.

Éppen ellenkezőleg, használhatjuk a módszert váltás nélküli () elem hozzáadása a tömb elejéhez:

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

A módszer használata váltás nélküli () módszerrel pop (), visszafelé sorban állhat, ha elemeket ad hozzá a tömb elejéhez és eltávolítja a tömb végéről.

A tömb elemeinek megfordítása és rendezése.

A tömb elemeinek megfordításához használhatjuk fordítva ():

Var myArray = ["visszaszámlálás", "végső", "a"]; console.log (myArray); // ["visszaszámlálás", "végső", "a"] myArray = myArray.reverse (); console.log (myArray); // ["Végső visszaszámlálás"]

Rendezze be a tömb elemeit ábécésorrend esetleg a módszer használatával rendezés ():

Var myArray = ["xilofonok", "zebrák", "juggernauts", "avokádók"]; console.log (myArray); // ["xilofonok", "zebrák", "juggernauts", "avokádók"] myArray = myArray.sort (); console.log (myArray); // ["avokádó", "juggernauts", "xilofon", "zebra"]

De ez nem működik a számokkal.

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

Ha rendezni kell a számokat, akkor a következő kódot használhatja:

Függvény compaNumbers (a, b) (return a - b;) var myArray =; console.log (myArray); // myArray = myArray.sort (hasonlítsd össze a számokat); console.log (myArray); //

Amint fent látható, egy egyszerű beillesztett funkcióval rendezés (), a számokat tartalmazó tömb helyesen lesz rendezve.

Tömbök kombinálása.

Összekapcsolhat 2 vagy több tömböt, és kaphat egy tömböt, amely az összefűzött tömb elemeit tartalmazza. Ehhez használjuk a módszert concat ():

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat (myArray2); 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"]

Egy tömb felosztása.

A függvény segítségével létrehozhat egy új tömböt, amely 1 vagy több elemet tartalmaz egy meglévő tömbből szelet ():

Var myArray = ["Ének", "Basszus", "Gitár", "Dob", "Alma", "Narancs"]; var myNewArray = myArray.slice (4); console.log (myNewArray); // ["Alma", "Narancs"]

Módszer szelet () 1 vagy 2 érvet vesz fel. Ha 1 argumentum (index) kerül átadásra, akkor a régi összes eleméből új tömb jön létre, az adott indexből kiindulva. Ha 2 argumentum kerül átadásra, akkor új tömb jön létre az első argumentumtól kezdve a második paraméterben átadott indexen lévő elemig, és nem tartalmazza az utolsót. Az érthetőség kedvéért nézzük meg az alábbi kódot:

Var myArray = ["Ének", "Basszus", "Gitár", "Dob", "Alma", "Narancs"]; var myNewArray = myArray.slice (0, 4); console.log (myNewArray); // ["Ének", "Basszus", "Gitár", "Dob"]

Elemek cseréje egy tömbben.

Használunk összeillesztés () elemek eltávolítására egy tömbből, de a tömb elemeit új elemekkel is helyettesíthetjük:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.slic (3, 1, "Scott Shriner"); // 1 elem cseréje index 3 console.log (myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

Módszer összeillesztés () mindig egy tömböt ad vissza, amely tartalmazza az eltávolított elemeket. A 2. sor 1 "Brian Bell" elemet ad vissza.

Következtetés

Ezek a cikkek leírták a JavaScript tömbökkel való munkavégzés módszereit. Néhány további elem megtekinthető az MDN -en, amelyeket nem tettem közzé ebben a bejegyzésben. Csak az IE9 +rendszerben működnek, ezért előfordulhat, hogy nem hasznosak.

Van mit hozzáfűzni? Vagy tud valami érdekes könyvtárat, amely segít a tömbök kezelésében? Kérlek, szólj hozzá!