JQUERY Törölje a tömbelemet érték szerint. Hogyan lehet törölni egy adott JavaScript tömb elemet? A Törlés funkció használata a tömbelem eltávolításához

váltás

Használja a tömb első elemének eltávolítását.

Például:

Var Array \u003d; Array.Shift ();

a tömb vezet:

Például:

Var Array \u003d; array.pop ();

a tömb vezet:

Mindkét módszer egy távoli elemet ad vissza;

összekapcsolás

Használjon.Splice () a tömbből származó elemek eltávolításához. .splice () két paramétert, kezdeti indexet és opcionális elemet kell eltávolítani. Ha a második paraméter nem. Plice () Törli az összes elemet a kezdeti indexből a tömb végéig.

Például:

Var Array \u003d; Array.splice (1, 2);

a levelek tömbjét tartalmazza:

A RETURN ARRAY.SPLICE () egy új tömb, amely távoli elemeket tartalmaz. A fenti példában a visszatérítés a következő:

Így a második paraméter csökkentése hatékonyan megszakítja a tömböt két tömbbe a megadott index kezdeti végével:

Var Array \u003d; Array.splice (2);

Levelek a tömböt tartalmazó és visszatér.

töröl

Használja a Törlés funkciót egy elem eltávolításához egy tömbből anélkül, hogy megváltoztatná a tömb hosszát:

Var Array \u003d; Konzol.log (tömb.length); // 5 törölje a tömböt; Konzol.log (tömb); // console.log (tömb.length); // öt

Array.prototype.length.

Hosszú értékű tömb hozzárendelése a hossza meghatározott értékre változik. Ha egy új érték kisebb, mint a tömb hossza, az elemek eltávolításra kerülnek az érték végéig.

Tömb \u003d; tömb.length \u003d 2; Konzol.log (tömb); //

A JavaScript. A kezelő törlése. Eltávolítja az objektum tulajdonát; Ha ugyanazon tulajdonságra nincs több hivatkozás, akkor automatikusan felszabadul.

Az interaktív példa forrását egy github tárolóban tárolják. Ha szeretne hozzájárulni az interaktív példákhoz, kérjük, klónozza a https://github.com/mdn/interactive-examples-t, és küldjön nekünk egy pull kérelmet.

Szintaxis

töröl. kifejezés

A variable által meghatározott változó nem konfigurálható. A következő példában a fizetés nem konfigurálható, és nem törölhető. Nem szigorú módban a törlési művelet hamis lesz.

FUNKCIÓ MUNKAVÁLLALÓK () (Fizetés törlése; var fizet,) munkavállaló ();

Nézze meg, hogyan viselkedik ugyanaz a kód szigorú módban. A hamis visszaküldése helyett a nyilatkozat emeli a szintaxiót.

"Használjon szigorú"; Funkció Alkalmazott () (Törlés fizetés; // Syntaxerror var fizetés,) // Hasonlóképpen, a törléshez való közvetlen hozzáférés a demofunkció () (// egyes kódok) demofunkciójának () (// egyes kódok) növelése; // Szintaktikai hiba.

Példák.

// létrehozza a Property Adminname-t a globális hatókörre. adminnév \u003d "xyz"; // létrehozza az ingatlan empcount a globális hatókör. // Mivel Var használunk, ez nem konfigurálható. Ugyanez igaz az is, és CONST. var empcount \u003d 43; Munkavállaló \u003d (név: "xyz", életkor: 5, kijelölés: "Fejlesztő"); // Adminname a globális hatókör tulajdonsága. // Törölhető, mivel var, // és ezért konfigurálható. Adminnév törlése; // Visszatérés igaz // Éppen ellenkezőleg, az empcount nem konfigurálható // Mivel a var használt. Az empcount törlése; // A hamis // törlés visszaadása az objektumok tulajdonságainak eltávolítására használható. Munkaelemek törlése. Name; // visszatér. // Még akkor is, ha az ingatlan nem létezik, törölje az "TRUE" értéket. Törölje a munkatársakat. // A True // Delete visszatérése nem befolyásolja a beépített statikus tulajdonságokat. Törölje a Math.pi-t; // FALSE // A munkatársak a globális hatókör tulajdonsága. // Mivel "var" nélkül definiálták, akkor megjelölve van konfigurálható. A munkavállalók törlése; // visszaadja az Igazi funkciót F () (var z \u003d 44, // DELETE DOCLEN "T befolyásolja a helyi változó neveket, törölje a z; // FALSE-t

törlés és a prototípus lánc

A következő példamutatásban töröljük egy objektum saját tulajdonát, míg egy azonos nevű ingatlan elérhető a prototípusláncon:

Funkció Foo () (this.Bar \u003d 10;) foo.prototype.BAR \u003d 42; var foo \u003d új foo (); // foo.BAR a // saját tulajdonhoz kapcsolódik. Konzol.log (foo.bar); // 10 // A saját tulajdonság törlése a // Foo objektumon belül. Foo.BAR törlése; // A TRUE // FOO.BAR visszatérése még mindig elérhető a // prototípus láncban. Konzol.log (foo.bar); // 42 // Törölje a tulajdonságot a prototípuson. Foo.prototype.BAR törlése; // Visszatérés TRUE // A "BAR" tulajdonság már nem lehet // örökölt a foo-tól, mivel az // törölte. Konzol.log (foo.bar); // határozatlan.

Tömbelemek törlése.

Ha töröl egy tömbelemet, a tömbhossz nem érinti. Ez akkor is megtartja, ha törli a tömb utolsó elemét.

Ha a törlési operátor eltávolítja a tömbelemet, az elem már nem a tömbben. A következő példában a fákat töröljük.

Var fák \u003d ["Redwood", "Bay", "Cedar", "Oak", "Maple"]; Törölje a fákat; Ha (3 fákban) (// ez nincs végrehajtva)

Ha szeretné, hogy létezik egy tömbelem, de nincs meghatározatlan érték, használja a meghatározatlan értéket a törlési operátor helyett. A következő példában a fák hozzárendelik a meghatározatlan értéket, de a tömbelem még mindig létezik:

Var fák \u003d ["Redwood", "Bay", "Cedar", "Oak", "Maple"]; Fák \u003d nincs meghatározva; Ha (3 fákban) (// ez végrehajtásra kerül)

Ha inkább egy tömbelemet szeretne eltávolítani a tömb tartalmának megváltoztatásával, használja a Splice módszert. A következő példában a fákat teljesen eltávolítják a tömbből a Splice használatával:

Var fák \u003d ["Redwood", "Bay", "Cedar", "Oak", "Maple"]; Fák.splice (3.1); Konzol.log (fák); // ["Redwood", "Bay", "Cedar", "Maple"]

Előírások.

Leírás	Állapot.	Megjegyzés
Ecmascript legújabb tervezet (ECMA-262)	Vázlat.
ECMASSCRIPT 2015 (6. kiadás, ECMA-262) A "Törlés operátor" meghatározása az említett specifikációban.	Alapértelmezett.
Ecmascript 5.1 (ECMA-262) A "Törlés operátor" meghatározása az említett specifikációban.	Alapértelmezett.
Ecmascript 1. kiadás (ECMA-262) A "Törlés operátor" meghatározása az említett specifikációban.	Alapértelmezett.	Kezdeti meghatározás. A JavaScript 1.2.

Böngésző kompatibilitás

Az ezen az oldalon található kompatibilitási táblázat strukturált adatokból származik. Ha "D szeretne hozzájárulni az adatokhoz, nézze meg a https://github.com/mdn/browser-compat-data, és küldjön nekünk egy pull kérést.

Frissítse a kompatibilitási adatokat a Githubon

	Asztali.						Mobil						szerver
	Króm.	Él.	Firefox.	Internet böngésző.	Opera.	Szafari.	Android webview.	Chrome az Android számára	Firefox az Android számára	Opera az Android számára	Szafari az iOS-on.	Samsung Internet	Csomópont.js.
töröl.	Chrome teljes támogatás 1	EDGE teljes támogatás 12	Firefox teljes támogatás 1	Azaz teljes támogatást 4	Opera teljes támogatás igen	Safari teljes támogatás igen	WebKite Android Teljes támogatás 1	Chrome Android teljes támogatás 18	Firefox Android Teljes támogatás 4	Opera Android Teljes támogatás Igen	Safari iOS Teljes támogatás Igen	Samsung Internet Android Teljes támogatás 1.0	nodejs Teljes támogatás Igen

Legenda.

Teljes támogatás Teljes támogatás

Keresztböngésző jegyzetek

Bár az Ecmascript az objektumok megvalósításától függően az Icmascript teszi lehetővé, úgy tűnik, hogy az összes főbb böngésző támogatja a legkorábbi hozzáadott ingatlanon alapuló iterációs sorrendet (legalábbis a prototípuson nem a tulajdonságok esetében). Az Internet Explorer esetében azonban, ha egy törlést használ a tulajdonságon, néhány zavaró viselkedési eredményt, megelőzve más böngésző segítségével egyszerű objektumok használata, mint az objektum literálok rendezett asszociatív tömbökként. Az Explorerben, míg az ingatlan Érték Valóban meghatározva van, ha egy később hozzáadja az ingatlant régi. Pozíció - nem az iterációs sorrend végén, amint azt az ingatlan törlése után elvárják, majd hozzáadta.

Csak a tömbökkel való munkavégzés módszereit írtam le.

Itt beszélünk a tömb elemeinek hozzáadásáról, eltávolításáról. A tömb fordítására és rendezéséről, valamint a tömbök vágására, cseréjére és kombinálására.

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

Használhatja a hosszúságú tulajdonságot, hogy új elemeket adjon hozzá egy tömbhöz:

Var myarray \u003d ["Apple", "Microsoft", "Google", "Facebook"]; myarray \u003d "Yahoo!"; Konzol.log (myarray); // [Apple, "Microsoft", "Google", "Facebook", "Yahoo!"]

Ez fog működni, mert A tömb elemei a semmiből számozva vannak, és hossz. Egyenként több. Hossz. Mindig egyenértékű index + 1.Tehát nagyon könnyű hozzáadni egy új elemet a tömb végéhez. Furcsa, de hozzáadhat egy elemet olyan helyzetbe, amely sokkal nagyobb, mint a tömb hossza:

Var myarray \u003d ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"; myarray \u003d "lindsey buckingham"; Konzol.log (myarray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", nem definiált × 95, "lindsey buckingham" console.log (myarray.length); // 100

Amint az észrevételekben látható, 95 üres rés és a "Lindsey Buckingham" elem hozzáadódik a tömb végéhez. Ezt követően 100-at kapunk. Egy másik módja annak, hogy új elemet adjon hozzá egy tömbhöz, a módszer használata nyom ():

Var myarray \u003d ["Paul McCartney", "John Lennon", "George Harrison"]; myarray.push ("Ringo Starr", "George Martin"); Konzol.log (myarray); // ["Paul McCartney", "John Lennon", "George Harrison", "Ringo Starr", "George Martin"]

Módszer nyom () Mindig visszaadja a tömb új hosszát (az 5. esetünkben). Hozzáadhat egy elemet használva splice ():

Var myarray \u003d ["makor", "bükk", "mongongo", "makadámia"]; myarray.splice (2, 0, "kesudió"); // hozzáadja a "kesudiót" az index 2 konzol.log (Myarray); // ["makk", "bükk", "kesudió", "Mongongo", "Macadamia"]

Amikor a második argumentum 0, ez azt jelenti, hogy egyetlen elem sem lesz eltávolítva, ezért az első érvben megadott pozícióba kerülnek a tömbhöz.

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

Távolítsa el az elemet kissé bonyolultabb, mint hozzáadja. Az elem eltávolítása a tömb végéből, használhatja pOP ():

Var myarray \u003d ["7-up", "sprite", "gyömbéres ale", "limonádé"]; myarray.pop (); Konzol.log (myarray); // ["7-up", "sprite", "gyömbér ale"]

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

Használhatja splice () módszer:

Var myarray \u003d ["Cassava", "Nutmeg", "Lupin", "Rhubarb"]; myarray.splice (2, 1); // Töröljön egy elemet egy index 2 konzol.log (Myarray); // ["Cassava", "Nutmeg", "Rhubarb"]

A módszerrel ellentétben splice (), Amely elemek hozzáadására szolgál, itt a második argumentum 1, amely azt mondja, hogy egy elemet szeretnénk eltávolítani egy 2-es index (vagy harmadik fiók). Ebben az esetben a "Lupin" elem visszavonult.

Törölhet egy tömbelemet az üzemeltető segítségével töröl:

Var myarray \u003d ["byte bandit", "Eliza", "Jeefo", "Michelangelo"]; Konzol.log (myarray.length); // 4 törölje a Myarray-t; // törlése eliza console.log (myarray.length); // 4 konzol.log (Myarray); // ["byte bandit", undefined × 1, "jeefo", "michelangelo"]

Az első fontos megjegyzés: törlés () Az elem eltávolítása után nem változtatja meg a tömb hosszát (még akkor is, ha a tömb utolsó eleme volt). Második: törlés () Megváltoztatja az eltávolított elem értékét a meghatározatlan, így a kapcsolatfelvétel közben myarray \u003d meghatározatlan..

Jó módja annak, hogy eltávolítsunk egy elemet a tömbből - Használja John Resig Array.Remove-t. A használat egyik példája az oldalról:

// Array eltávolítás - a John Resig (MIT licencelt) array.prototype.remove \u003d funkció (a, to) (var rose \u003d this.slice ((|| -ból) + 1 || ehig. \u003d.< 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);

Előfordulhat, hogy a Viral Patel döntését, az Underscore.js egyik funkcióját, vagy a jquery grep ().

Haladó, B. JavaScript. Van egy módszer shift () Amely eltávolítja az első elemet a tömbben, és visszaadja értékét. Lássuk a kódot:

Var myarray \u003d ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; Konzol.log (myarray.length); // 4 var frészlet \u003d myarray.Shift (); Konzol.log (elsődleges); // matt kramer console.log (myarray.length); // 3 konzol.log (myarray); // ["Jason Bieler", "Tom Defile", "Phil Varone"]

A módszer használata shift () Töröltük az elemet, de megmentettük értékét az elsődleges változónkban. A tömb hossza 4-től 3-ig változott.

Ez a módszer hasznos lehet a módszerrel együtt. nyom (). Használja őket együtt, hatékonyan megteremthetjük az elemek sorát a tömbben. A tömb hosszát megtartjuk az elejétől az elem eltávolításával, és egy újat adunk hozzá.

Éppen ellenkezőleg, használhatjuk a módszert törés () Elem hozzáadása a tömb elejére:

Var myarray \u003d ["apito", "castanets", "maraca"]; Konzol.log (myarray.length); // 3 myarray.unshift ("Chime bár", "tan-tan"); Konzol.log (myarray.length); // 5 konzol.log (myarray); // ["Chime Bar", "Tan-Tan", "Apito", "Castanets", "Maraca"]

A módszer használata törés () egy módszerrel pop () Az ellenkező irányba sorvételt hozhat létre azzal, hogy elemeket ad az elejére, és eltávolítja a tömb végétől.

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

A tömb elemek megfordításához használhatjuk fordított ():

Var myarray \u003d ["visszaszámlálás", "végleges", "a"]; Konzol.log (myarray); // ["visszaszámlálás", "végleges", "a"] myarray \u003d myarray.Reverse (); Konzol.log (myarray); // ["Végső visszaszámlálás"]

Rendezze a tömb elemeit ábécé sorrendben, talán a módszer segítségével rendezés ():

Var ryarray \u003d ["xylofones", "zebraras", "jugrernauts", "avokádók"]; Konzol.log (myarray); // ["xylofones", "zebrák", "jugrernauts", "avokádók"] myarray \u003d myarray.sort (); Konzol.log (myarray); // ["Avokádó", "Juggernauts", "xylophones", "zebras"]

De nem fog működni a számokkal.

Var myarray \u003d; Konzol.log (myarray); // myarray \u003d myarray.Sort (); Konzol.log (myarray); //

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

Funkció összehasonlító (A, B) (visszatérés a - b;) Var Myarray \u003d; Konzol.log (myarray); // myarray \u003d myarray.Sort (összehasonlítószerek); Konzol.log (myarray); //

A fentiek szerint egy egyszerű funkcióval beillesztve rendezés () A tömböt tartalmazó számokat megfelelően rendezik.

Kombinálva a tömböket.

Két vagy több tömböt kombinálhatunk, és 1 tömböt kaphatunk, amely tartalmazza a csatlakoztatott tömbök elemeit. Ehhez használja a módszert cONCAT ():

Var myarray \u003d ["Jay Ferguson", "Andrew Scott"]; Var myarray2 \u003d ["Chris Murphy", "Patrick Pentland"]; var mynewarray \u003d ryarray.concat (myarray2); Konzol.log (mynewarray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Var myarray \u003d ["Jay Ferguson", "Andrew Scott"]; var mynewarray \u003d ryarray.concat ("Chris Murphy", "Patrick Pentland"); Konzol.log (mynewarray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

A tömb elválasztása.

Új tömböt hozhatunk létre, amely 1 vagy több elemet tartalmaz egy meglévő tömbből egy funkcióval slice ():

Var myarray \u003d ["ének", "basszus", "gitár", "dob", "almák", "narancs"]; var mynewarray \u003d myarray.slice (4); Konzol.log (mynewarray); // ["alma", "narancs"]

Módszer szelet () 1 vagy 2 érv. Ha 1 argumentumot továbbít (index), akkor az új tömb a régi elemekből származik, az indextől kezdve. Ha van 2 érvek, az új tömb jön létre az elemek, kezdve az első paramétert az elemet az index továbbított a második paraméter, nem beleértve az utóbbi. Ahhoz, hogy világosabb legyen, nézzük meg az alábbi kódot:

Var myarray \u003d ["ének", "basszus", "gitár", "dob", "almák", "narancs"]; var mynewarray \u003d myarray.slice (0, 4); Konzol.log (mynewarray); // ["ének", "basszus", "gitár", "dob"]

Elemek cseréje a tömbben.

Használunk splice () Az elemek eltávolítása a tömbből, de az elemet is helyettesíthetjük az új elemekre:

Varyray \u003d ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myarray.splice (3, 1, "Scott Shriner"); // Cserélje ki az 1 elemet egy index 3 konzol.log (Myarray); // ["folyók cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

Módszer splice () Mindig visszatérjen egy tömböt tartalmazó elemeket, amelyeket töröltek. A 2. sorban visszaküldik 1 elem "Brian Bell".

Következtetés

Ezek a cikkek a JavaScript tömbökkel való munkavégzést írják le. Néhány további elem megtekinthető az MDN-en, amelyet nem vettem fel ebben a hozzászólásban. Csak az IE9 + -ban dolgoznak, így haszontalanok lehetnek.

Van valami hozzáadni? Vagy ismeri az érdekes könyvtárat, amely segít a tömbök kezelésében? Hozzászólás, kérem!

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

// a Marcoci szerkesztette a tanácsot

próbáld ezt:

Funkció WantDelete (elem, arr) (a (var i \u003d 0, i)

remélem, ez segít Önnek

Van-e módja annak, hogy eltávolítsunk egy elemet a JavaScript-tömbből?

Tekintettel a tömbre:

Var ary \u003d ["Három", "hét", "tizenegy"];

Szeretnék valamit tenni:

Eltávolítás ("hét", ary);

Megnéztem a Splice-t (), de csak törli a pozíciószámot, míg szükségem van valamire, hogy eltávolítsa az elemet az értékével.

Hagyja, hogy a kommentswithoutdeledarray \u003d commentsarray.filter ((megjegyzés) \u003d\u003e! (Comment.Id \u003d\u003d\u003d CommentID));

Itt van az a verzió, amelyben az inarray jquery funkciót használják:

Var index \u003d $ .inarray (tétel, tömb); ha (index! \u003d -1) (Array.splice (index, 1);)

Ezt a funkció segítségével érheti el LOWASH. _.Remove.

var Array \u003d ["Három", "Hét", "Eleven"]; VAR Evens \u003d _.Remove (tömb, függvény (e) (e! \u003d \u003d\u003d "7";); Konzol.log (Evens);

CONST _ \u003d igényel ("Lodash"); _.without (, 2); // -\u003e

Valójában nem értem, miért lehetetlen megoldani

Arr \u003d arr.filter (érték \u003d\u003e érték! \u003d\u003d "hét");

Vagy talán vanília JS-t szeretnénk használni

Arr \u003d arr.filter (Visszatérési érték! \u003d\u003d 7 "));

Egy másik változat:

Ha (! Array.Prototype.removearr) (Array.prototype.Removearr \u003d funkció (LARR) (IF (! Array.isaray (ARR)) ARR \u003d; // Légy kedves az embereknek Itt .. ez lehet nekem! Var, mint ez; ha (Arr.Length) (var i \u003d 0; míg (i) -1) (ez.Splice (I, 1);) más i ++; )) Visszatérés; )))))))))

Ez a cikluson belül ez az indexof () ismét, de feltételezve, hogy az eltávolításra szolgáló tömb kicsi a tisztítandó tömbhöz viszonyítva; Minden eltávolítás csökkenti a míg ciklust.

Ez lehetővé teszi, hogy a következőket tegye:

Var ary \u003d ["Három", "hét", "tizenegy"]; Var arywithoutseven \u003d ary.filter (Visszatérési érték! \u003d "Hét")); Konzol.log (arywithoutseven); // visszatér ["három", "tizenegy"]

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

Ne használja a DELETE opciót - ez egy lyukat készít a tömbben, mivel a távoli elem után nem oldja meg az elemeket.

\u003e Array.prototype.Remove \u003d funkció (V) (... Törölje ezt ...); \u003e Var myarray \u003d ["3", "24", "55", "2"]; meghatározatlan\u003e myarray.Remove ("55"); MEGHATÁROZOTT\u003e MYARRY ["3", "24", "2"]

Egy bélés megteszi

Var ary \u003d ["Három", "hét", "tizenegy"]; // eltávolítás "hét" a "SEVEN" tétel a Array var filteredary \u003d ary.filter (funkció (E) (E! \u003d \u003d\u003d "hét"))) // \u003d\u003e ["Három", "Eleven"] // ECMA6 (nyíl) Funkció szintaxis): var szűrés \u003d ary.filter (e \u003d\u003e e! \u003d\u003d "Seven")

Ez a szűrő funkciót JS-ben használja. Ez támogatott IE9 és magasabb.

szűrő () A fordított hívás funkciót egyszer okozza a tömb minden egyes elemére, és létrehoz egy új tömböt minden olyan értéket, amelyre a visszahívás visszaadja az igazi értéket. A visszahívást csak a tömbindexekre hívják, amelyek hozzárendeltek az értékek; Nem hívják azokat az indexeket, amelyeket töröltek, vagy akiket soha nem rendelnek hozzá értékekhez. Egy olyan tömbelemek, amelyek nem adnak át visszahívási tesztet, egyszerűen kihagyják és nem szerepelnek az új tömbbe.

Így többnyire ugyanaz, mint mindenki másnak (VAR kulcs az ARY) (...) megoldásokkal, kivéve, hogy az INTIA támogatja az IE6-t.

Elvileg a szűrő olyan kényelmi módszer, amely sokkal jobb (és lánc), ellentétben az (AFAIK) tervezővel ellentétben.

Nézd meg:

A (var i tömb) esetében (ha ([i] \u003d\u003d "hét") (Array.spice (I, 1); szünet;)

És a funkcióban:

Funkció eltávolítás (tömb, elem) (ha ([i] \u003d\u003d item) (tömb [i] \u003d\u003d tétel) (Array.splice (I, 1); szünet;)))))))))))));

Az összes megfelelő elem eltávolítása a tömbből (és nem csak az első, ahogy úgy tűnik, hogy a leggyakoribb válasz itt):

Míg ($ .inarray (tétel, tömb)\u003e -1) (Array.spice ($. Inarray (tétel, tömb), 1);)

A kemény munkát használtam, de megértette, hogy az anyanyelvedre akarsz menni.

A trükk az, hogy a kezdetektől kezdve egy tömbön keresztül menjen át, így az elemek eltávolításakor nem fogja elrontani az indexeket.

Var deleteme \u003d funkció (ARR, ME) (VAR I \u003d Arr. Length, míg (i--), ha (ARR [i] \u003d\u003d\u003d me) arr.spice (i, 1);) var arr \u003d ["narancssárga "," Piros "," fekete "," narancs "," fehér "," narancs "]; Delleteme (ARR, "Orange");

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

Funkció CleanarrayOraRayOrrayOdeRayOdeRayFicifinterms (Array, NwanedTermsArray) ($ .Each (UndraTestTermarsray, funkció (index, érték) (érték); ifex (index\u003e -1) (Array.splice (index, 1);)));

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

Var NotInclude \u003d ["NEM", "NEM", "ELSŐ", "Utolsó", "Előző", "Következő", "Kutya", "Macskák"; var splitterms \u003d ["Hívás", "Napló", "Kutya", "Macskák", "Téma", "Változás", "Árképzés"]; Cleanarrayofspecifficisterms (splitters, notinclude)

Megpróbáltam használni a Funkció módját a JBARON fenti, de azt találtam, hogy meg kell mentenem az eredeti tömb-t anélkül, hogy később használná a későbbi használatát, és új tömböt hoz létre az alábbiak szerint:

Var NewArray \u003d ReferenceArty;

Funkció NewArremoveiem (tömb, elem, NewArray) (a (var i \u003d 0; i)< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Ezután ezt használom:

Var velsid \u003d rekord.get ("edény"); VAR Othervessels \u003d Új tömb (); NewArremoveiem (Vesselrr, Handelid, Othervessels);

Most a Shiparr nem érintetlen marad, és minden alkalommal, amikor elvégeztem a fenti kódot, az Othervessels Array mindent tartalmaz, kivéve az utolsó Caid elemet.

az indexof egy lehetőség, de megvalósítása elsősorban a teljes tömböt keresi a jelentés, így a végrehajtási idő növekszik a tömb méretével. (Tehát ez minden böngészőben van, azt hiszem, csak ellenőriztem a Firefoxot).

Nincs IE6 ellenőrizni, de biztonságos ajánlatot hívnék, hogy ellenőrizheti legalább egy millió elemet a tömb második másodpercenként, így gyakorlatilag minden ügyfélgépen. Ha [a tömb mérete] * [A keresési lekérdezések másodpercenként] több mint egymillió növekedhetnek, akkor egy másik megvalósítást kell figyelembe vennie.

Alapvetően használhat egy objektumot, hogy létrehozzon egy indexet a tömbhöz, például:

Var index \u003d ("Három": 0, "Seven": 1, "Eleven": 2);

Minden normális JavaScript környezet megteremti egy keresési indexet olyan tárgyakat, így gyorsan lefordítani a kulcs értékét, függetlenül attól, hogy hány ingatlan van tárgya.

Ez csak egy alapvető módszer, az Ön igényeitől függően több objektumot és / vagy tömböt kombinálhat, hogy ugyanazokat az adatokat gyorsan hozzáférhessen a különböző tulajdonságok kereséséhez. Ha megadja az Ön konkrét igényeit, konkrétabb adatstruktúrát kínálhatok.

// Ez a funkció lehetővé teszi az eltávolítás egyenletes tömböt a Array var eltávolítófromarr \u003d funkcióból (Arr.length, new_arr \u003d, sort_fn \u003d funkció (A, B) (A, B) (A - B;); az (I \u003d 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; }

Példa a használatra

Vararr \u003d, "abc", 1, "1", 1]; EltávolításFromarr (ARR, 1); // ["2", "ABC", "1"] VARRR \u003d [, 2, "A" ,,]; EltávolításFromarr (ARR,); //]

Legyen ARR \u003d; Konzol.log (ARR); // eredményezze az index \u003d arr.indexof (30); ha (index\u003e -1) (arr.spice (index, 1);) konzol.log (ARR); // eredmény

Var index \u003d array.indexof ("tétel"); Ha (index! \u003d - 1) (Array.splice (index, 1);)