Matriser

En array är en ordnad samling av värden. Värdena i en array kallas element, och varje element kännetecknas av en numerisk position i arrayen, som kallas ett index. Arrayer in JavaScriptär otypade: arrayelement kan vara av vilken typ som helst och olika element i samma array kan ha olika typer. Arrayelement kan till och med vara objekt eller andra arrayer, vilket gör att du kan skapa komplexa datastrukturer som arrayer av objekt och arrayer av arrayer.

JavaScript-arrayindex är nollbaserade och använder 32-bitars heltal - det första elementet i en array har index 0. Arrayer i JavaScript är dynamiska: de kan växa och krympa efter behov; det finns inget behov av att deklarera fasta storlekar på arrayer när de skapas, eller att omallokera minne när deras storlek ändras.

Arrayer i JavaScript är en specialiserad form av objekt, och arrayindex betyder inte mycket mer än bara egenskapsnamn, som av en slump är heltal.

Skapar arrayer

Det enklaste sättet att skapa en array är med en bokstavlig, som är en enkel kommaseparerad lista med arrayelement inom hakparenteser. Värden i en arrayliteral behöver inte vara konstanter - de kan vara vilket uttryck som helst, inklusive objektliterals:

var tomt = ; // Tom array var numbers = ; // En matris med fem numeriska element var misc = [ 1.1, true, "a", ]; // 3 element olika typer+ avslutande kommatecken var bas = 1024; var tabell = ; // Array med variabler var arrObj = [, ]; // 2 arrayer inuti som innehåller objekt

Den bokstavliga arraysyntaxen tillåter ett valfritt efterföljande kommatecken, dvs. den bokstavliga [,] matchar en array med två element, inte tre.

Ett annat sätt att skapa en array är att anropa Array()-konstruktorn. Du kan anropa en konstruktör på tre olika sätt:

Anrop konstruktör utan argument:

Var arr = new Array();

I det här fallet kommer en tom array som motsvarar en bokstavlig att skapas.

Anropa konstruktorn med ett enda numeriskt argument som anger längden på arrayen:

Var arr = new Array(10);

I det här fallet kommer en tom array med den angivna längden att skapas. Denna form av anrop av Array()-konstruktorn kan användas för att förallokera minne för en array om antalet element är känt i förväg. Observera att detta inte lagrar några värden i arrayen.

Ange uttryckligen i konstruktoranropet värdena för de första två eller flera elementen i arrayen, eller ett icke-numeriskt element:

Var arr = new Array(5, 4, 3, 2, 1, "test");

I det här fallet blir konstruktorargumenten värdena för elementen i den nya arrayen. Att använda arrayliterals är nästan alltid lättare än att använda Array()-konstruktorn så här.

Läs- och skrivmatriselement

Matriselement nås med hjälp av . Till vänster om parenteserna måste vara en matrisreferens. Inom parenteserna måste det finnas ett godtyckligt uttryck som returnerar ett icke-negativt heltalsvärde. Denna syntax är lämplig för både att läsa och skriva värdet av ett arrayelement. Därför är alla följande JavaScript-satser giltiga:

// Skapa en array med ett element var arr = ["värld"]; // Läs element 0 var värde = arr; // Skriv värde till element 1 arr = 3,14; // Skriv värde till element 2 i = 2; arr[i] = 3; // Skriv värde till element 3 arr = "hej"; // Läs element 0 och 2, skriv värde till element 3 arr] = arr;

Låt mig påminna dig om att arrayer är en specialiserad sorts objekt. Hakparenteser som används för att komma åt matriselement fungerar precis som hakparenteser som används för att komma åt objektegenskaper. JavaScript-tolken konverterar de numeriska indexen i parentes till strängar - index 1 blir strängen "1" - och använder sedan strängarna som egenskapsnamn.

Det finns inget speciellt med att konvertera numeriska index till strängar: samma sak kan göras med vanliga objekt:

var obj = (); // Skapa ett enkelt objekt obj = "ett"; // Indexera det med heltal

En egenskap hos arrayer är att när man använder egenskapsnamn som är icke-negativa heltal, bestämmer arrayer automatiskt värdet på length-egenskapen. Till exempel skapades arrayen ovan med ett enda element. Den tilldelade sedan värden till dess element vid index 1, 2 och 3. Som ett resultat av dessa operationer ändrades värdet på arrayens längdegenskap till 4.

Du bör tydligt skilja mellan arrayindex och objektegenskapsnamn. Alla index är egenskapsnamn, men endast egenskaper med namn representerade av heltal är index. Alla arrayer är objekt, och du kan lägga till egenskaper till dem med valfritt namn. Men om du trycker på egenskaper som är arrayindex, svarar arrayer genom att uppdatera värdet på length-egenskapen vid behov.

Observera att det är tillåtet att använda negativa och icke-heltalsnummer som arrayindex. I det här fallet konverteras siffror till strängar, som används som egenskapsnamn.

Lägga till och ta bort arrayelement

Vi har redan sett att det enklaste sättet att lägga till element i en array är att tilldela värden till nya index. Du kan också använda push()-metoden för att lägga till ett eller flera element i slutet av en array:

Var arr = ; // Skapa en tom array arr.push("noll"); // Lägg till värde för att avsluta arr.push("one",2); // Lägg till ytterligare två värden

Du kan också lägga till ett element i slutet av en array genom att tilldela ett värde till arr-elementet. Du kan använda metoden unshift() för att infoga ett element i början av en array, vilket flyttar befintliga element i arrayen till högre indexpositioner.

Arrayelement kan tas bort med delete-operatorn, precis som vanliga objektegenskaper:

Var arr = ; ta bort arr; 2 i arr; // false, arrayindex 2 är inte definierat arr.length; // 3: Delete-operatorn ändrar inte egenskapen length för arrayen

Att ta bort ett element liknar (men något annorlunda) som att tilldela odefinierat till det elementet. Observera att användningen av delete-operatorn på ett element i en array inte ändrar värdet på egenskapen length, och det flyttar inte heller element med högre index nedåt för att fylla tomrummet efter elementet som tas bort.

Det är också möjligt att ta bort element i slutet av en array genom att helt enkelt tilldela ett nytt värde till egenskapen length. Arrayer har en pop()-metod (motsatsen till push()), som minskar längden på arrayen med 1 och returnerar värdet på det borttagna elementet. Det finns också en shift()-metod (motsatsen till unshift()), som tar bort elementet i början av arrayen. Till skillnad från delete-operatorn flyttar metoden shift() alla element ner till en position under deras nuvarande index.

Slutligen finns det en multi-purpose splice()-metod som låter dig infoga, ta bort och ersätta arrayelement. Den ändrar värdet på egenskapen length och skiftar arrayelement med lägre eller högre index efter behov. Vi kommer att diskutera alla dessa metoder lite senare.

Flerdimensionella arrayer

JavaScript stöder inte "riktiga" flerdimensionella arrayer, men det gör det trevligt att simulera dem med arrayer av arrayer. För att komma åt ett dataelement i en array av arrayer räcker det att använda operatorn två gånger.

Anta till exempel att den variabla matrisen är en array av arrayer av tal. Varje element i matris[x] är en matris med tal. För att komma åt ett specifikt nummer i en array kan du använda uttrycket matris[x][y]. Följande är ett specifikt exempel där en tvådimensionell array används som multiplikationstabell:

// Skapa en flerdimensionell array var table = new Array(10); // Det finns 10 rader i tabellen för(var i = 0; i

Array klass metoder

ECMAScript 3-standarden definierar ett antal bekvämlighetsfunktioner för att arbeta med arrayer som en del av Array.prototype , som är tillgängliga som metoder för vilken array som helst. Dessa metoder kommer att presenteras i följande underavsnitt.

join() metod

Metoden Array.join() konverterar alla arrayelement till strängar, sammanfogar dem och returnerar den resulterande strängen. Som ett valfritt argument till metoden kan du skicka en sträng som kommer att användas för att separera element i resultatsträngen. Om en avgränsningssträng inte anges används ett kommatecken. Till exempel resulterar följande utdrag i strängen "1,2,3":

Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"

reverse() metod

Metoden Array.reverse() vänder ordningen på elementen i en array och returnerar en omordnad array. Permutationen utförs direkt på den ursprungliga arrayen, dvs. den här metoden skapar inte en ny array med omordnade element, utan ordnar om dem i en redan befintlig array. Till exempel resulterar följande fragment, som använder metoderna reverse() och join() i strängen "3,2,1":

Var arr = ; arr.reverse().join(); // "3,2,1"

sort() metod

Metoden Array.sort() sorterar elementen i den ursprungliga arrayen och returnerar den sorterade arrayen. Om metoden sort() anropas utan argument, utförs sorteringen i alfabetisk ordning (elementen konverteras tillfälligt till strängar för jämförelse, om det behövs). Odefinierade element flyttas till slutet av arrayen.

För att sortera i någon annan ordning än alfabetisk kan du skicka en jämförelsefunktion som ett argument till sort()-metoden. Denna funktion ställer in vilket av dess två argument som ska komma först i den sorterade listan. Om det första argumentet måste komma före det andra, måste jämförelsefunktionen returnera ett negativt tal. Om det första argumentet ska följa det andra i den sorterade matrisen måste funktionen returnera ett tal större än noll. Och om två värden är ekvivalenta (dvs deras ordning är inte viktig), bör jämförelsefunktionen returnera 0:

Var arr = ; arr.sort(); // Alfabetisk ordning: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Numerisk ordning: 4, 33, 222, 1111 return a-b; // Returnerar värde 0 // beroende på sorteringsordning a och b)); // Sortera bakåt, från största till minsta arr.sort(function(a,b) (retur b-a));

Lägg märke till hur bekvämt det är att använda en icke namngiven funktion i det här utdraget. Jämförelsefunktionen används bara här, så det finns ingen anledning att ge den ett namn.

concate() metod

Metoden Array.concat() skapar och returnerar en ny array som innehåller elementen i den ursprungliga arrayen som concat()-metoden anropades på och värdena för eventuella argument som skickas till concat()-metoden. Om något av dessa argument i sig är en array läggs dess element till i den returnerade arrayen. Det bör emellertid noteras att det inte finns någon rekursiv transformation av en array av arrayer till en endimensionell array. Concat()-metoden modifierar inte den ursprungliga arrayen. Nedan följer några exempel:

Var arr = ; arr.concat(4, 5); // Returnera arr.concat(); // Returnerar arr.concat(,) // Returnerar arr.concat(4, ]) // Returnerar ]

slice() metoden

Metoden Array.slice() returnerar en del, eller undermatris, av den angivna matrisen. De två argumenten för metoden definierar början och slutet av det returnerade fragmentet. Den returnerade arrayen innehåller elementet vars nummer anges i det första argumentet, plus alla efterföljande element upp till (men inte inklusive) elementet vars nummer anges i det andra argumentet.

Om endast ett argument ges, innehåller den returnerade arrayen alla element från startpositionen till slutet av arrayen. Om något av argumenten är negativt specificerar det elementnumret i förhållande till slutet av matrisen. Således motsvarar argumentet -1 det sista elementet i arrayen, och argumentet -3 motsvarar det tredje elementet i arrayen från slutet. Här är några exempel:

Var arr = ; arr skiva(0,3); // Returnerar arr.slice(3); // Returnerar arr.slice(1,-1); // Returnerar arr.slice(-3,-2); // Lämna tillbaka

splice() metod

Metoden Array.splice() är en generisk metod som infogar eller tar bort element i en array. Till skillnad från metoderna slice() och concat() ändrar metoden splice() den ursprungliga arrayen som den anropades på. Observera att metoderna splice() och slice() har mycket liknande namn men utför helt olika operationer.

Metoden splice() kan ta bort element från en array, infoga nya element eller göra båda samtidigt. Arrayelement skiftas efter behov för att bilda en sammanhängande sekvens efter infogning eller borttagning.

Det första argumentet till splice()-metoden anger positionen i arrayen från vilken infogningen och/eller borttagningen kommer att utföras. Det andra argumentet anger antalet element som ska tas bort (klippas ut) från arrayen. Om det andra argumentet utelämnas tas alla arrayelement från den angivna arrayen till slutet av arrayen bort. Metoden splice() returnerar en array av de borttagna elementen, eller (om inga element har tagits bort) en tom array.

De två första argumenten till splice()-metoden bestämmer elementen i arrayen som ska tas bort. Dessa argument kan följas av valfritt antal valfria argument som anger de element som ska infogas i arrayen, med början på den position som anges i det första argumentet.

Var arr = ; arr.splice(4); // Returnerar , arr = arr.splice(1,2); // Returnerar , arr = arr.splice(1,1); // Returnerar ; arr = arr = ; arr.splice(2,0,"a","b"); // Returnerar ; arr=

metoderna push() och pop().

Metoderna push() och pop() tillåter arrayer att behandlas som stackar. Metoden push() lägger till ett eller flera nya element i slutet av arrayen och returnerar dess nya längd. Metoden pop() utför den omvända operationen - tar bort det sista elementet i arrayen, minskar längden på arrayen och returnerar värdet som den togs bort. Observera att båda dessa metoder ändrar den ursprungliga arrayen, inte skapar en modifierad kopia av den.

unshift() och shift() metoder

Metoderna unshift() och shift() fungerar ungefär som push() och pop(), förutom att de infogar och tar bort element i början av arrayen, inte i slutet. Metoden unshift() flyttar befintliga element mot högre index för att frigöra utrymme, lägger till elementet eller elementen i början av arrayen och returnerar den nya längden på arrayen. Metoden shift() tar bort och returnerar det första elementet i arrayen, och flyttar alla efterföljande element ner en position för att fylla det lediga utrymmet i början av arrayen.

Hälsningar till alla som är intresserade av ett sådant ämne som flerdimensionella JavaScript-matriser och sortering. I den aktuella publikationen kommer jag att försöka täcka detta ämne i alla detaljer.

Därför kommer du, efter att ha läst artikeln, att lära dig varför flerdimensionella arrayer används i webbapplikationer, hur de skapas och hur de kan hanteras och sorteras. Låt oss börja lära oss!

Hur skapas flerdimensionella arrayer och vad är de till för?

Till att börja med är det värt att komma ihåg hur en vanlig endimensionell array skapas.

array =

Kom nu ihåg att en flerdimensionell array är en array av arrayer. Jag håller med, det låter som en tautologi. Läs dock definitionen igen. Faktum är att en flerdimensionell array består av ett visst antal kapslade .

Tänk på följande situation. I början av ett visst spel anger användaren sitt namn, och efter slutet visas en betygstabell med spelarnas namn och deras register på skärmen.

Det är tydligt att sådan information lagras i databasen. Men när vi hämtar det från databasen får vi en flerdimensionell array. Varje subarray lagrar trots allt spelarens inloggning och antalet poäng.

Det hela kommer att se ut så här:

var results = [["Markus", 333], ["Natasha", 211], ["Alex", 124] ];

Som du kan se kan information lagras heterogent. Det kan vara strängar, siffror och till och med . Detta är möjligt eftersom arrayer i är otypade.

I detta fall sker åtkomsten till elementen genom en dubbel operatör.

För att konsolidera materialet, analysera ett litet program.

Värdet av resultat =

var results = [["Markus", 333], ["Natasha", 211], ["Alex", 124] ]; document.getElementById("demo").innerHTML = resultat;

Matriser är ett ganska bekvämt sätt att lagra beställda komplexa data under bearbetning. Dessutom är det väldigt bekvämt att arbeta med dem och samtidigt är deras bearbetningshastighet ganska hög.

Sätt att sortera data

För arrayer har JavaScript en inbyggd metod som kallas sort() . Detta verktyg är mycket flexibelt. Och nu ska jag förklara varför.

Om du använder metoden utan parametrar, så sorterar den automatiskt subarrayerna efter det första elementet i alfabetisk ordning. Så, när du ringer resultat. sort() det analyserade objektet kommer att se ut så här:

Alexey, 124

Markus, 333

Natasha, 211

Och om du byter elementen i varje kapslad array får du:

124, Alexey

211, Natasha

333, Marcus

I det här fallet, för jämförelse, konverteras alla element tillfälligt till strängar.

Om, för att lösa några specifik uppgift du behöver en funktion som sorterar elementen på ett icke-standardiserat sätt, då kan du skriva det själv och skicka det som en parameter till sort() . Samtidigt bör man ta hänsyn till det anpassad funktion ska returnera:

• ett positivt tal (välj i allmänhet 1) om det första specificerade elementet följer efter det andra vid jämförelse;
• ett negativt tal (vanligtvis -1) om det andra valda elementet ska följa det första;
• null om de två värdena som testas är lika.

Som ett exempel, låt oss sortera den initiala resultatmatrisen efter poäng. Resultaten kommer att sorteras från största till minsta. Detta kan göras på två sätt.

I det första alternativet ändrade jag sorteringslogiken, d.v.s. i en situation där det är nödvändigt att returnera ett positivt tal, returnerar jag ett negativt och vice versa.

Rekordtabell:

var results = [["Markus", 333], ["Natasha", 211], ["Alex", 124] ]; results.sort(RecordSort); funktion RecordSort(a, b) (om (a > b) returnerar -1; annars om (a< b) return 1; else return 0; } for(var i=0; i b) return 1; else if (a < b) return -1; else return 0; }

function RecordSort(a, b) ( if (a > b) return 1; else if (a< b) return -1; else return 0; }

Och efter det, lägg till metoden ovan.

Slutsatsen görs på ett liknande sätt.

Jag skulle vilja uppmärksamma er på en viktig poäng. När du använder dessa funktioner sker alla ändringar i den array som du tillämpar dem på. Således, om du behöver bevara den ursprungliga formen av data, skapa en kopia och sedan redigera den.

Tja, så jag pratade om flerdimensionella arrayer och deras sortering. Om du gillade artikeln, prenumerera på bloggen och läs andra lika intressanta publikationer. Jag kommer att vara tacksam för reposter. Ses snart!

Hejdå!

Med vänlig hälsning, Roman Chueshov

I den här artikeln kommer vi att titta på vanliga JavaScript-matriser med numeriska index. Arrayer deklareras med hakparenteser:

var fruits = ["Äpple", "Apelsin", "Åsna"]

För att extrahera ett element, sätt dess index inom hakparenteser. Första index 0:

var fruits = ["Äpple", "Apelsin", "Åsna"] alert(frukter) alert(frukter) alert(frukter)

Vi kan också få längden på en JavaScript-array:

var fruits = ["Äpple", "Apelsin", "Donkey"] alert(fruits.length)

hoppsan! Vi har skapat en array med två frukter och en åsna. Nu måste vi ta bort åsnan.

pop och push-metoder

Popmetoden i JavaScript tar bort ett arrayelement och returnerar det.

Följande exempel visar hur "Donkey" hämtas från en array:

var fruits = ["Apple", "Orange", "Donkey"] alert("Jag tar bort "+fruits.pop()) // Nu har vi bara ["Apple","Orange"] alert("Nu storleken på arrayen: "+fruits.length) // åsnan borttagen

Observera att pop modifierar själva arrayen.

Pops motsvarighet är push-metoden, som lägger till ett element till en array. Till exempel glömde vi att lägga till en persika:

var fruits = ["Äpple", "Orange"] fruits.push("Peach"); // nu har vi ["Apple", "Orange", "Peach"] alert("Sista objekt:"+frukter)

Skapa en array stilar med element "Jazz", "Blues";

Lägg till värdet "Rock'n'Roll";

Ersätt det andra värdet från slutet med värdet "Classic". Du bör sluta med en array: "Jazz", "Classic", "Rock'n'Roll". Koden bör fungera för alla arraylängder;

Extrahera det sista värdet från arrayen och visa det via varning.

Lösning

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // eller: styles = "Rock"n"Roll" // 3 styles = "Klassisk " // 4 alert(styles.pop())

skift/avväxlingsmetoder

Shift/unshift-metoderna fungerar i slutet av arrayen, men du kan också använda shift för att flytta element uppåt (det första värdet i arrayen tas bort med element shift). Unshift-metoden tillåter JavaScript att lägga till ett element i en array från slutet:

var fruits = ["Apple", "Orange"] var apple = fruits.shift() // nu har vi bara ["Orange"] fruits.unshift("Citron") // nu har vi ["Citron", " Orange"] alert(frukter. längd) // 2

Både växling och avväxling kan arbeta på flera element samtidigt:

var fruits = ["Apple"] fruits.push("Orange","Peach") fruits.unshift("Pineapple","Citron") // array ser nu ut så här: ["Ananas", "Citron", " Apple ", "Orange", "Peach"]

Uppgift för självuppfyllelse

Skriv kod för att visa via varning slumpmässigt värde från array arr:

var arr = ["Plum","Orange","Donkey","Morot","JavaScript"]

Obs: Koden för att få ett slumptal från det lägsta till det högsta värdet (inklusive) är följande:

var rand = min + Math.floor(Math.random()*(max+1-min))

Lösning

Vi måste extrahera ett slumptal mellan 0 och arr.length-1 (inklusive):

var arr = ["Plum","Orange","Donkey","Morot","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Itererar över en array

I JavaScript görs iteration över en array med en for-loop:

var fruits = ["Ananas", "Citron", "Äpple", "Apelsin", "Persika"] for(var i=0; i=0 kontrollera snabbare än i . Vilket i JavaScript påskyndar arrayuppslagningar.

Använda längd för att trimma en array

Med hjälp av egenskapen length kan du trimma en array så här:

Du ställer in längden och webbläsaren trimmar arrayen.

Array är ett objekt, vilket innebär

Faktum är att i JavaScript är en Array ett objekt , vadderat automatisk installation längd och speciella metoder.

Detta skiljer sig från konceptet på andra språk där arrayer är ett sammanhängande minnessegment. Detta skiljer sig också från en kö- eller stackbaserad länkad lista.

Icke-numeriska array-nycklar

Nycklarna är siffror, men de kan ha vilka namn som helst:

arr = arr = 5 arr.prop = 10 // gör inte detta

I JavaScript är arrayer hashtabeller, med sina prestandafördelar, men också några nackdelar.

Till exempel, push/pop fungerar bara på de yttersta elementen i en array, så de är otroligt snabba.

push fungerar bara med slutet:

var arr = ["Min", "array"] arr.push("något") alert(arr) // string "array"

Shift/unshift-metoderna är långsamma eftersom de behöver numrera om hela arrayen. Skarvmetoden kan också få numreringen att ändras:

Så shift/unshift är långsammare än push/pop. Ju större array, desto längre tid tar det i JavaScript att sortera arrayen.

Uppgift för självuppfyllelse

Vad blir resultatet? Varför?

arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // ?

Lösning

Eftersom arrayer är objekt, arr ..är faktiskt ett metodanrop till ett objekt som obj metod:

arr() // samma som arr() // syntaktisk fel, men konceptuellt samma: arr.2() // omskriven i samma stil som obj.method() this = arr i detta fall skickas till funktionen, så att innehållet i arr skrivs ut. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",function

Glesa arrayer, längdbeskrivning

Length-egenskapen låter dig inte få storleken på en array i JavaScript, men sista index+ 1 . Detta är viktigt om vi pratar om glesa arrayer, med "luckor" i indexen.

I följande exempel kommer vi att lägga till två element till de tomma frukterna, men längdvärdet förblir 100:

var fruits = // tomma array fruits = "Peach" fruits = "Apple" alert(fruits.length) // 100 (men det finns bara 2 element i arrayen)

Om du försöker mata ut en gles array kommer webbläsaren att returnera värdena för de saknade indexen som tomma element:

var fruits = // tomma array fruits = "Peach" fruits = "Apple" alert(frukter) //,Peach,Apple (eller något liknande)

Men en array är ett objekt med två nycklar. Saknade värden tar inte plats.

Sparse arrays beter sig bisarrt när array-metoder tillämpas på dem. De har ingen aning om att index saknas:

var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // pop "Apple" (vid index 9) alert(fruits.pop()) // pop not givet element(vid index 8)

Försök att undvika glesa arrayer. Hur som helst, deras metoder kommer inte att fungera normalt. Använd istället Object .

Ta bort från en array

Som vi vet är arrayer objekt, så vi kan använda delete för att ta bort ett värde:

var arr = ["Gå", "till", "hem"] radera arr // nu arr = ["Gå", odefinierat, "hem"] alert(arr) // inte satt

Du kan se att värdet tas bort, men inte på det sätt vi skulle vilja eftersom arrayen innehåller ett oinställt element.

Raderingsoperatören tar bort ett nyckel-värdepar, och det är allt. Naturligtvis, eftersom en array bara är en hash, blir positionen för det borttagna elementet odefinierad .

Oftast behöver vi ta bort ett element utan att lämna "hål" mellan indexen. Det finns en annan metod som hjälper oss med detta.

skarvningsmetod

Splitsmetoden kan ta bort element och ersätta dem i flerdimensionella JavaScript-matriser. Dess syntax är:

arr.splice(index, deleteCount[, elem1, ..., elemN])

Tar bort elementet deleteCount, med början på index , och infogar sedan elem1, ..., elemN i dess ställe.

Låt oss titta på några exempel:

var arr = ["Gå", "till", "hem"] arr.splice(1, 1) // ta bort 1 element som börjar vid index 1 alert(arr.join(",")) // ["Go " , "hem"] (1 objekt har tagits bort)

Så du kan använda skarv för att ta bort ett element från en array. Matriselementnumren flyttas för att fylla tomrummet:

var arr = ["Gå", "till", "hem"] arr.splice(0, 1) // ta bort 1 element som börjar vid index 0 alert(arr) // "to" blev det första elementet

Följande exempel visar hur man byter ut element:

Splitsmetoden returnerar en array av borttagna element:

var arr = ["Gå", "till", "hem", "nu"]; // remove the first 2 elements var removed = arr.splice(0, 2) alert(removed) // "Go", "to" =0; i--) ( if (c[i] == cls) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( className: "öppen meny" ) removeClass(obj , "öppna") removeClass(obj, "blabla") alert(obj.className) // menu

I exemplet ovan sätts variabel c i början av loopen, och i är satt till dess sista index.

Själva slingan exekveras i motsatt riktning och slutar med villkoret i>=0 . Detta beror på att i>=0 kontrolleras snabbare än i . Vilket snabbar upp egenskapssökningen i c .

skivningsmetod

Du kan extrahera en del av en array med metoden slice(begin[, end]): var arr = ["Varför", "lär dig", "JavaScript"]; var arr2 = arr.slice(0,2) // tar 2 element från 0 alert(arr2.join(", ")) // "Varför, lär dig"

Observera att den här metoden inte ändrar antalet element i arrayen i JavaScript, utan kopierar en del av den.

Du kan utelämna det andra argumentet för att få alla element från ett visst index:

var arr = ["Varför", "lär dig", "JavaScript"]; var arr2 = arr.slice(1) // accepterar alla element från 1 alert(arr2.join(", ")) // "learn, JavaScript"

Metoden stöder negativa index, precis som String#slice .

omvänd metod

En annan användbar metod är omvänd. Låt oss säga att jag vill få den sista delen av domänen, som "com" från "my.site.com". Så här gör du:

var domain = "my.site.com" var last = domain.split(".").reverse() alert(last)

Observera att JavaScript-matriser stöder en komplex syntax (reverse()) för att anropa en metod och sedan extrahera ett element från den resulterande matrisen.

Du kan skapa längre samtal som reverse() 0] arr.sort() alert(arr) // 1, 15, 2

Kör ovanstående kod. Du får beställningen 1 , 15 , 2 . Detta beror på att metoden konverterar allt till en sträng och använder den lexikografiska ordningen som standard.

• I. Iterering över riktiga arrayer
• för varje metod och relaterade metoder
• för slinga
• Korrekt användning av for...in loop
• för...of loop (implicit användning av iterator)
• Explicit användning av en iterator
• Använder verkliga array-iterationsmetoder
• Konvertera till riktig array
• En anteckning om körtidsobjekt

I. Iterering över riktiga arrayer Det finns för närvarande tre sätt att iterera över elementen i en riktig array:

metod Array.prototype.forEach ;

klassisk för loop;

En "välformad" för...in loop.

Dessutom, snart, med tillkomsten av den nya ECMAScript 6 (ES 6)-standarden, förväntas ytterligare två metoder:

for...of loop (implicit användning av iterator);

explicit användning av en iterator.

1. ForEach-metoden och relaterade metoder Om ditt projekt är utformat för att stödja funktionerna i standarden ECMAScript 5 (ES5), kan du använda en av dess innovationer - forEach-metoden.

Användningsexempel:
var a = ["a", "b", "c"]; a.forEach(function(entry) (console.log(entry); ));
I allmänhet kräver användningen av forEach inkluderingen av es5-shim-emuleringsbiblioteket för webbläsare som inte har inbyggt stöd för denna metod. Dessa inkluderar IE 8 och högre tidiga versioner som fortfarande används idag.

Fördelen med forEach är att det inte finns något behov av att deklarera lokala variabler för att lagra index och värde för det aktuella arrayelementet, eftersom de automatiskt skickas till callback-funktionen som argument.

Om du är orolig för den möjliga kostnaden för att ringa en återuppringning för varje element, oroa dig inte och läs detta.

ForEach är designat för att iterera över alla element i en array, men utöver det ger ES5 flera mer användbara metoder för att iterera över alla eller vissa element, plus att göra något med dem:

• every - returnerar true om för varje element i arrayen returnerar callback ett värde som utvärderas till true .
• some - returnerar true om återuppringningen för minst ett element i arrayen returnerar ett värde som utvärderas till true .
• filter - skapar en ny array som innehåller de element i den ursprungliga arrayen för vilka återuppringningen returnerar sant.
• map - skapar en ny array som består av de värden som returneras av återuppringningen.
• reducera - Reducerar en array till ett enstaka värde genom att applicera en callback på varje element i arrayen i tur och ordning, med början med det första (kan vara användbart för att beräkna summan av arrayelement och andra sammanfattningsfunktioner).
• reduceRight - fungerar på samma sätt som reducera, men itererar över elementen i omvänd ordning.

2. For-slingan Bra gammal för stenar:

Var a = ["a", "b", "c"]; var index; för (index = 0; index< a.length; ++index) { console.log(a); }
Om längden på arrayen inte ändras genom hela slingan, och själva slingan tillhör en prestandakritisk kodbit (vilket är osannolikt), så kan du använda den "mer optimala" versionen av som lagrar längden på array:

Var a = ["a", "b", "c"]; var index, len; för (index = 0, len = a.längd; index< len; ++index) { console.log(a); }
Teoretiskt sett bör den här koden köras lite snabbare än den föregående.

Om ordningen för att iterera över elementen inte är viktig, kan du gå ännu längre när det gäller optimering och bli av med variabeln för att lagra längden på arrayen genom att ändra iterationsordningen till den omvända:

Var a = ["a", "b", "c"]; var index; for (index = a.length - 1; index >= 0; --index) ( console.log(a); )
Men i moderna JavaScript-motorer betyder sådana spel med optimering vanligtvis ingenting.

3. Korrekt användning av for...in loop Om du rekommenderas att använda en for...in loop, kom ihåg att iterering över arrayer inte är vad den är avsedd för. I motsats till den vanliga missuppfattningen, itererar inte for...in loopen över arrayindexen, utan objektets otaliga egenskaper.

Men i vissa fall, som att iterera över glesa arrayer, kan för...in vara användbart, så länge du vidtar försiktighetsåtgärder, som visas i exemplet nedan:

// a - sparse array var a = ; a = "a"; a = "b"; a = "c"; for (var nyckel i a) ( if (a.hasOwnProperty(nyckel) && /^0$|^\d*$/.test(nyckel) && nyckel