Arrayer i javascript i enkla ord. Växa och trunkera en array. Omordning av arrayelement i omvänd ordning - omvänd

God dag till alla. Alexey Gulynin är i kontakt. I den senaste artikeln tittade vi på växelhuskonstruktionen i javascript. I den här artikeln skulle jag vilja berätta vilka arrayer som finns i Javascript. Konceptet med en array spelar ut viktig roll inte bara i Javascript, utan i all programmering. En variabel, till exempel en array, innehåller inte ett element utan flera. Syntaxen för att skapa en array är följande:

Var mas = new Array(värde1, värde2,..., värdeN);

I I detta fall en arrayvariabel mas skapas med värdena indikerade inom parentes. Observera att arrayen skapas med det nya nyckelordet. Du kan komma åt arrayelement genom att ange arraynamnet och hakparentes arrayindex. Arrayindexet sätts från noll. Låt oss ge ett exempel på en array som består av 4 element och visar det andra elementet:

var mas = new Array("privet", 1, 10, 5); document.write("Andra arrayelement = "+mas); // siffran 10 kommer att visas

Om vi ​​sätter mas så kommer "liguster" att skrivas ut, eftersom indexeringen av arrayen börjar från noll. Låt oss nu ta reda på hur man visar alla element i en array. För att göra detta måste du använda en slinga. Förutom att kunna loopar i Javascript behöver du känna till egenskapen length för arrayer, som returnerar antalet element i en array (eller, med andra ord, dess längd). Låt oss skriva ut längden på mas-arrayen:

var mas = new Array("privet", 1, 10, 5); document.write("Arraylängd = "+mas.length); // siffran 4 kommer att visas

Skriver ut alla arrayelement:

var mas = new Array("privet", 1, 10, 5); var i; för (i = 0; i< mas.length; i++) document.write(mas[i]+" ");

Hittills har vi tittat på endimensionella arrayer. I allmänhet kan arrayer vara flerdimensionella. Det viktigaste du behöver förstå är att till exempel en tvådimensionell array är en array vars element är arrayer. Låt oss titta på det här problemet: du måste skapa en tvådimensionell 3 x 3 array, vars element specificeras av användaren, och mata ut denna array. Här kommer vi att använda promptoperatören för att begära ett nummer från användaren:

var mas = new Array(); //deklarera arrayen const n = 3; //deklarera en konstant, dvs. Vår array är 3 gånger 3 stor //för att definiera en tvådimensionell array måste du använda en dubbel loop var i; var j; för (i = 0; i< n; i++) { mas[i] = new Array();//Здесь мы как раз каждый элемент массива делаем массивом for (j = 0; j < n; j++) { mas[i][j] = prompt("[" + i +","+j+"]= " ,"..."); //запрашиваем число у пользователя } } for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { document.write("[" + i +","+j+"]= "+ mas[i][j]);} //выводим элемент массива document.write("
"); //gå till ny linje efter varje fylld rad i arrayen)

I vårt fall motsvarar en tvådimensionell array (till exempel) följande struktur: mas=[,,] . Du kan se att arrayen har 3 element, som var och en är en array i sig.

Till en början var uppgiften för Javascript att göra dynamiska webbplatser. I min praktik har jag aldrig använt tvådimensionella arrayer, endast endimensionell, så kunskapen om arrayer som du fick från den här artikeln kommer att vara tillräckligt. I en av följande artiklar kommer jag att prata om Array-objektet, dess egenskaper och metoder.

Vad är en array

En matris är en datatyp som lagrar numrerade värden. Varje numrerat värde kallas ett arrayelement, och numret som elementet är associerat med kallas dess index. JavaScript-matriser är otypade, vilket innebär att ett element i matrisen kan vara av vilken typ som helst, och olika element en array kan ha olika typer. Förutom JavaScript-matriserär dynamiska, vilket betyder att deklarera fixad storlek inte nödvändigt och du kan lägga till nya element när som helst.

Skapa en Array

En array kan skapas på två sätt, det första är att skapa en array med hjälp av en array literal - hakparenteser, inom vilken det finns en lista med element separerade med kommatecken.

Var tom = ; //tom array var nummer = ; //array med 5 numeriska element var diff = ; //array med 3 element olika typer

Värdena behöver inte vara enkla (siffror eller strängar) - de kan också vara andra uttryck, till exempel: objektsliteral, andra arrayer eller funktioner.

Var num = 700; var tab = , num + 1];

Det andra sättet att skapa en array är att anropa Array()-konstruktorn. Det finns tre sätt att anropa Array()-konstruktorn.

• Anropa en konstruktor utan argument:

var b = new Array();

I det här fallet skapas en tom array, motsvarande en tom literal.

• Konstruktorn specificerar uttryckligen värdena för n arrayelement:

var b = new Array(1, 3, 5, 8, "sträng", true);

I det här fallet får konstruktören en lista med argument, som blir element i den nya arrayen. Argumenten skrivs till arrayen i den ordning som de anges.

• Tilldela utrymme för senare tilldelning av värden. Detta görs genom att ange ett nummer i arraydefinitionen parentes:

var b = new Array(5);

Denna metod för att definiera en array innebär att tilldela arrayen ett visst antal element (som vart och ett har värdet odefinierat) och sedan tilldela värden allt eftersom skriptet fortskrider. Detta formulär används vanligtvis för att förallokera en array om dess längd är känd i förväg.

Läsa, skriva och lägga till arrayelement

Matriselement nås med operatorn. Arrayelement i JavaScript numreras från noll. För att uppnå nödvändigt element array måste du ange dess nummer inom hakparenteser.

Var-tal = ; document.write(nummer + ", "); //första elementet i arrayen document.write(nummer + ", "); //andra element i arrayen document.write(nummer + ", "); //tredje elementet i arrayen document.write(numbers); //fjärde elementet i arrayen

Arrayelement kan ändras:

Var-tal = ; siffror = 10; //ändrade det första elementet i arrayen -

Tillägga nytt element array, tilldela bara ett nytt värde:

Var-tal = ; siffror = 7; //blev

Obs: JavaScript-matriser kan lagra valfritt antal element av vilken typ som helst.

Array längd

Alla arrayer, oavsett om de är skapade med Array()-konstruktorn eller definierade med en arrayliteral, har särskild egendom längd, som återkommer Totala numret element lagrade i en array. Eftersom arrayer kan ha odefinierade element (de med värdet undefined) är en mer exakt formulering att length-egenskapen alltid är ett större än arrayelementets största index (antal). Length-egenskapen uppdateras automatiskt och förblir korrekt när nya element läggs till i arrayen.

Var v = new Array(); // v.length == 0 (inget element är definierat) v = new Array(1,2,3); // v.length == 3 (element 0–2 definierade) v = ; // v.length == 2 (element 0 och 1 är definierade) document.write(v.length);

För att få det sista elementet i arrayen kan du också använda egenskapen length:

Var v = ["JavaScript", "Egenskap", "Arrayer"]; document.write(v);

Det sista elementet har ett index 1 mindre än längden på arrayen, eftersom räkningen börjar från noll. Därför, om du inte vet det exakta antalet element, men du behöver hänvisa till det sista elementet i arrayen, använd posten: v.length - 1.

Slingor genom arrayelement

Den vanligaste användningen av egenskapen length är att loopa genom arrayelement:

Det här exemplet förutsätter att elementen i arrayen är sammanhängande och börjar vid det första elementet (index 0). Om så inte är fallet, innan du kommer åt varje element i arrayen, måste du kontrollera om det är definierat:

Var frukter = ["äpple", "banan", "jordgubbe", "persika"]; för(var i = 0; i

En loop kan också användas för att initiera arrayelement:

Var bar = new Array(10); för(var i = 0; i

Trunkering och odling av en array

När man arbetar med arrayer uppdateras length-egenskapen automatiskt så att vi inte behöver oroa oss för det själva. Men en sak som är värd att nämna är att längdegenskapen är tillgänglig inte bara för läsning, utan även för skrivning. Om length-egenskapen är inställd på ett värde som är mindre än det nuvarande, trunkeras arrayen till den nya (specificerade) längden, alla element som inte faller inom det nya indexintervallet kasseras och deras värden går förlorade, även om längden är senare kommer värdena inte att återställas.

Var foo = ; foo.length = 1; //förkorta till 1 element - foo.length = 4; //återställ det tidigare antalet element document.write(foo); //inget tidigare värde

Mest på ett enkelt sätt rensning av arrayen blir: foo.length = 0.

Om egenskapen length görs större än dess nuvarande värde, kommer nya odefinierade element att läggas till i slutet av arrayen, vilket ökar arrayen till den angivna storleken.

Ta bort Array Elements

Delete-operatorn skriver värdet odefinierat till ett arrayelement, medan själva elementet fortsätter att existera. För att ta bort element så att de återstående elementen flyttas till det lediga utrymmet måste du använda en av de fördefinierade arraymetoderna. Metoden Array.shift() tar bort det första elementet i arrayen, pop() tar bort det sista elementet i arrayen, splice() tar bort ett eller flera element var som helst i arrayen. Hur man använder dessa metoder kommer att beskrivas i detalj i nästa kapitel.

Flerdimensionella arrayer

Kom ihåg att JavaScript-matriser kan innehålla andra matriser som element. Denna funktion kan användas för att skapa flerdimensionella arrayer. För att komma åt element i en array av arrayer behöver du bara använda hakparenteser två gånger.

Var matris = [ , , ]; document.write(matris); //centralt element valt

Låt oss titta på vad som skrivs i exemplet: matris är en matris av matriser med tal. Alla element i matris[n] är en array av tal. För att komma åt ett specifikt nummer i en array måste du skriva matris[n][n], de andra hakparenteserna indikerar indexet för elementet i den interna arrayen.

//analog föregående post- skapande med konstruktorn var table = new Array(3); för(var i = 0; i

Associativa arrayer

Objekt kan användas som associativa arrayer. Lite teori - associativa arrayer (även kallade hash-tabeller) låter dig använda strängar istället för index. Att använda associativa arrayer är mycket likt att använda ett egenskapsnamn vanligt föremål, men i det här fallet när du arbetar i arrayformat. Eftersom JavaScript inte har metoder för att arbeta med associativa arrayer används de mycket mindre frekvent än vanliga, även om de lika gärna kan vara användbara för att lagra information och göra det lättare att komma ihåg element som behöver nås.

Var s_list = nytt objekt(); s_list["fat"] = "Fett"; s_list["small"] = "Liten"; s_list["name"] = "Homer"; for (var x i s_list) //visa alla element document.write(s_list[x] + "
");

• Översättning

De flesta applikationer som utvecklas idag kräver interaktion med någon form av datamängd. Att hantera element i samlingar är en vanlig operation som du förmodligen har stött på. När du till exempel arbetar med arrayer kan du utan att tänka använda en vanlig for loop, som ser ut ungefär så här: for (var i=0; i< value.length; i++){} . Однако, лучше, всё-таки, смотреть на вещи шире.

Anta att vi behöver visa en lista med produkter och, om nödvändigt, dela upp den i kategorier, filtrera, söka igenom den, ändra den här listan eller dess element. Kanske måste du snabbt utföra några beräkningar som involverar elementen i en lista. Låt oss säga att du behöver lägga till något med något, multiplicera något med något. Är det möjligt att hitta verktyg i JavaScript som låter dig lösa sådana problem snabbare och mer bekvämt än att använda en vanlig for loop?

Faktum är att det finns sådana faciliteter i JavaScript. Några av dem diskuteras i materialet, vars översättning vi presenterar för din uppmärksamhet idag. I synnerhet talar vi om spread-operatorn, for...of loop, och metoderna include(), some(), every(), filter(), map() och reduce(). Vi kommer mest att prata om arrayer här, men de tekniker som diskuteras här är generellt lämpliga för att arbeta med andra typer av objekt.

Det bör noteras att recensioner moderna tillvägagångssätt JS-utveckling inkluderar vanligtvis exempel som förbereds med hjälp av pilfunktioner. Kanske använder du dem inte så ofta - kanske för att du inte gillar dem, kanske för att du inte vill spendera för mycket tid på att lära dig något nytt, eller så är de helt enkelt inte rätt för dig. Därför kommer här, i de flesta situationer, två alternativ för att utföra samma åtgärder att visas: att använda normala funktioner(ES5) och använda pilfunktioner (ES6). För de som är nya i att arbeta med pilfunktioner är inte pilfunktioner motsvarigheten till funktionsdeklarationer och funktionsuttryck. Du bör inte ersätta det ena med det andra. Särskilt beror detta på att i vanliga och pilfunktioner nyckelord detta beter sig annorlunda.

1. Spridningsoperator Spridningsoperatorn låter dig "expandera" arrayer genom att ersätta deras element istället för arrayer på den plats där denna operator används. Ett liknande tillvägagångssätt har föreslagits för objektliteraler.▍Styrkor hos spridningsoperatören

• Det är enkelt och snabbt sätt"dra ut" dess individuella element från en array.
• Denna operatör är lämplig för att arbeta med array- och objektliteral.
• Detta är en snabb och intuitiv metod för att arbeta med funktionsargument.
• Tilläggsoperatören tar inte mycket plats i koden - den ser ut som tre punkter (...).

▍Exempel Anta att du står inför uppgiften att visa en lista över dina favoritgodis utan att använda en slinga. Med tilläggsoperatorn görs detta så här:

2. For…of-slingan Operatorn for…of är utformad för att korsa itererbara objekt. Det ger tillgång till enskilda element sådana objekt (särskilt till arrayelement), vilket till exempel gör att de kan modifieras. Det kan betraktas som en ersättning för det vanliga för slinga.▍ Styrkor hos for…of-slingan

• Det här är ett enkelt sätt att lägga till eller uppdatera samlingsobjekt.
• For...of-loopen låter dig utföra olika beräkningar med hjälp av element (summering, multiplikation och så vidare).
• Den är bekväm att använda när du behöver kontrollera eventuella förhållanden.
• Dess användning leder till att man skriver renare och mer läsbar kod.

▍Exempel Låt oss säga att du har en datastruktur som beskriver innehållet i en verktygslåda och du vill visa dessa verktyg. Så här gör du med en for...of loop:

3. Metoden include() Metoden include() används för att kontrollera närvaron av ett visst element i en samling, i synnerhet till exempel en viss sträng i en array som innehåller strängar. Denna metod returnerar sant eller falskt beroende på resultaten av testet. När du använder det är det värt att tänka på att det är skiftlägeskänsligt. Om till exempel samlingen innehåller strängelement SCHOOL , och kontroll av dess närvaro med include() utförs på linjeskolan , metoden kommer att returnera false .▍Strengths of the include()-metoden

• Metoden include() är användbar för att skapa enkla mekanismer för datahämtning.
• Det ger utvecklaren ett intuitivt sätt att fastställa förekomsten av viss data i en array.
• Det är bekvämt att använda i villkorliga uttryck för att modifiera, filtrera element och utföra andra operationer.
• Dess användning leder till förbättrad kodläsbarhet.

▍Exempel Anta att du har ett garage, representerat av en array med en lista över bilar, och du inte vet om en viss bil finns i detta garage eller inte. För att lösa detta problem måste du skriva kod som låter dig kontrollera om en bil står i garaget. Låt oss använda metoden include():

4. Some()-metoden Some()-metoden låter dig kontrollera om några av elementen du letar efter finns i arrayen. Baserat på resultatet av kontrollen returnerar den sant eller falskt . Den liknar metoden include() ovan, förutom att dess argument är en funktion snarare än, till exempel, en vanlig sträng för metoden some().

• Metoden some() låter oss kontrollera om arrayen innehåller minst ett av elementen vi är intresserade av.
• Den utför ett tillståndstest med den funktion som skickas till den.
• Denna metod är bekväm att använda.

▍Exempel Anta att du är ägare till en klubb, och i allmänhet är du inte intresserad av vem exakt som kommer till din klubb. Vissa besökare får dock inte komma in på klubben, då de är benägna att överkonsumera alkoholdrycker, enl. minst, i händelse av att de befinner sig i din anläggning på egen hand och det inte finns någon med dem som kan ta hand om dem. I detta fall får en grupp besökare komma in i klubben endast om minst en av dem är minst 18 år. För att automatisera denna typ av kontroll kommer vi att använda metoden some(). Nedan visas dess tillämpning i två versioner.ES5

ES6

5. Every()-metoden Every()-metoden går igenom arrayen och kontrollerar vart och ett av dess element för överensstämmelse med ett visst villkor, returnerar sant om alla element i arrayen uppfyller villkoret, och false om annat. Du kan se att den liknar some()-metoden.▍Styrker av every()-metoden

• Metoden every() låter dig kontrollera om alla element i en array uppfyller ett villkor.
• Villkor kan ställas in med hjälp av funktioner.
• Det främjar ett deklarativt förhållningssätt till programmering.

▍Exempel Låt oss återgå till föregående exempel. Där släppte man in besökare under 18 år i klubben, men någon skrev ett uttalande till polisen, varpå man hamnade i en obehaglig situation. Efter att allt var klart bestämde du dig för att du inte behövde allt detta och skärpte reglerna för att besöka klubben. Nu kan en grupp besökare komma in i klubben endast om varje medlem i gruppen är minst 18 år. Som förra gången kommer vi att överväga att lösa problemet i två versioner, men den här gången kommer vi att använda varje metod().ES5

ES6

6. Filter()-metoden Filter()-metoden låter dig skapa, baserat på en viss array, en ny array som endast innehåller de element i den ursprungliga arrayen som uppfyller ett givet villkor ▍Strengths av filter()-metoden

• Metoden filter() undviker modifiering av den ursprungliga matrisen.
• Det låter dig bli av med onödiga element.
• Det förbättrar kodläsbarheten.

▍Exempel Anta att du från en lista med priser endast behöver välja de som är större än eller lika med 30. Låt oss använda filter()-metoden .ES5 för att lösa det här problemet

ES6

7. Map()-metod Map()-metoden liknar filter()-metoden genom att den också returnerar en ny array. Det används dock för att modifiera elementen i den ursprungliga arrayen.▍Styrker av metoden map()

• Map()-metoden undviker behovet av att ändra elementen i den ursprungliga arrayen.
• Den kan användas för att enkelt modifiera arrayelement.
• Det förbättrar kodläsbarheten.

▍Exempel Låt oss säga att du har en lista över produkter med priser. Din chef behöver ny lista varor vars priser sänks med 25 %. Låt oss använda metoden map() .ES5 för att lösa det här problemet

ES6

8. Metoden reduce() Metoden reduce() låter dig i sin enklaste form summera elementen i numeriska arrayer. Med andra ord reducerar det arrayen till ett enda värde. Detta gör att du kan använda den för att utföra olika beräkningar.▍ Styrkor för metoden reduce().

• Med metoden reduce() kan du beräkna summan eller medelvärdet av elementen i en array.
• Denna metod påskyndar och förenklar beräkningar.

▍Exempel Anta att du behöver beräkna dina utgifter för veckan, som lagras i en array. Låt oss lösa det här problemet med metoden reduce() .ES5

ES6

Lägg till taggar

Matriser är en av de mest använda typerna av variabler som låter dig lagra många sekventiella värden på "ett ställe." Men när det kommer till JavaScript finns det utrymme för förbättringar.

I den här artikeln ska vi titta på tre föga kända tekniker som kan användas när du arbetar med arrayer.

1. Lägga till anpassade egenskaper till arrayer

Om du använder sökning för att hitta definitionen av en array inom JavaScript-språk, då kommer de flesta källor att hävda det den här typen Värdet på en variabel representeras som ett objekt.

Generellt sett är många av de saker vi möter i JavaScript objekt. Det skulle vara rättvist att notera att språket också innehåller "primitiva" datatyper, men deras värden används på något sätt i egenskaper inuti objekt.

2. Åtkomst till arrayelement i en loop

Eftersom matrisindex bara kan ta positiva värden börjar räkningen från noll. Vi kan senare använda detta index för att komma åt arrayelementet vid en given loopiteration.

ECMAScript6 introducerade ett sätt att scrolla genom en array utan att använda index, men genom en ny for…of loop.

For...of-loopen är utformad för att iterera genom elementen i en array utan att påverka elementets index.

Var ary = ["apelsin", "äpple", "litchi"]; for (låt objekt av ary)( console.log(item); ) // "orange", "äpple", "lychee" Som jämförelse: utmatning av objektindex i en for-loop. var ary = ["apelsin","äpple","litchi"]; för (var objekt = 0; objekt< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Antalet element är inte dimensionen på arrayen

När vi talar om storleken på en array tänker vi vanligtvis på det som antalet element som lagras i den. Faktum är att detta inte är helt sant - längdegenskapen beräknas beroende på elementets maximala index.

Längdegenskapen är mycket tvetydig. För att verifiera detta, titta bara på följande manipulationer:

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6

I det sista exemplet räckte det med att placera elementet i den femte positionen, vilket resulterade i att längden på arrayen blev 6. Om du tror att index från 0 till 4 kommer att skapas automatiskt, kommer du att ha fel. Detta kan kontrolleras med in-operatorn.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 i ary); // falskt

I det här fallet skulle det vara rättvist att kalla arrayen "gles".

Vi kan också manipulera egenskapen length för att trimma arrayer. Exemplet nedan visar att "förlora" elementet vid index 5 genom att minska egenskapen length för arrayen.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 ary.length = 2; console.log(ary.length); // 2 console.log(ary); // odefinierat

I JavaScript, såväl som i andra programmeringsspråk, används olika metoder för att arbeta med arrayer.

Metoder förenklar konstruktionen av logik och dess implementering i ett skript.

Nedan finns grundläggande metoder för att arbeta med arrayer i JS.

skjuta på

Metoden push() lägger till ett värde i slutet av arrayen.

Låt arr = ; arr.push(312); console.log(arr); // →

pop

Metoden pop() tar bort det sista elementet från arrayen eller returnerar dess värde.

Låt arr = ; arr.pop(); console.log(arr); // →

Med hjälp av möjligheten att få värdet av det sista elementet i en array som ett exempel kan vi få bildformatet:

Låt img = "https://example.com/img/namn.png"; let format = img.split(".").pop(); console.log(format); // → png console.log(img.split(".")); // → ["https://exempel", "com/img/namn", "png"]

avväxling

Metoden unshift() lägger till ett element i början av arrayen.

Låt arr = ; arr.unshift(312); console.log(arr); // →

flytta

Metoden shift() tar bort det första elementet från arrayen.

Låt arr = ; arr.shift(); console.log(arr); // → ;

Det måste förstås att vid användning skiftmetoder och unshift ändrar varje element i arrayen sitt index. Detta kan sakta ner programexekveringen om arrayen är stor. dela

Metoden split() används för att omvandla en sträng till en array. Split delar en sträng enligt den angivna parametern.

Låt str = "Anya, Masha, Sasha, Dasha"; // detta är en sträng låt arr = str.split(", "); console.log(arr); // → ["Anya", "Masha", "Sasha", "Dasha"] är en array

Ansluta sig

Metoden join() kombinerar matriselement till en sträng med avgränsningstecknet som anges i parametern.

Låt arr = ["Notpad++", "Sublime", "VSCode"]; // detta är en array låt str = arr.join(", "); console.log("Redaktörer för kod: " + str); // → "Redaktörer för kod: Notpad++, Sublime, VSCode"

skiva

Metoden slice() skapar en ny array till vilken den kopierar element från källan, med början från elementet med indexet för den första parametern som skickas till metoden, till elementet med indexet för den andra parametern.

Till exempel: slice(3, 7) returnerar element med index 3, 4, 5, 6. Elementet med index 7 kommer inte att inkluderas i arrayen.

Om slice() skickas en parameter med negativt värde, då returnerar den en ny array med antalet element som anges i parametern, men som redan är tagna från slutet av den ursprungliga arrayen.

Slicemetoden ändrar inte den ursprungliga arrayen.

Här är några exempel på metoden slice() i aktion:

Låt arr = ["A", "B", "C", "D", "E", "F", "G"]; // Returnerar en array som innehåller element med index från 2 till 5 console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // Returnerar en ny array som innehåller element med index från 3 till arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // Returnerar en kopia av den ursprungliga arrayen console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // Returnerar en ny array som består av sista tre element i källkoden console.log(arr.slice(-3)); // → ["E", "F", "G"]

splitsa

Metoden splice() modifierar innehållet i en array genom att ta bort befintliga element och/eller lägga till nya.

Syntax:

Array.splice(start, deleteCount[, item1[, item2[, ...]]])

Alternativ:

• start - Indexet där man ska börja byta array. Om det är större än längden på arrayen kommer det verkliga indexet att ställas in på längden på arrayen. Om det är negativt, anger elementets index från slutet.
• deleteCount - Ett heltal som anger antalet gamla element som ska tas bort från arrayen. Om deleteCount är 0 tas inga element bort. I det här fallet måste du ange minst ett nytt element. Om deleteCount mer kvantitet element som finns kvar i arrayen från startindexet, då kommer alla element fram till slutet av arrayen att raderas.
• itemN - Valfria parametrar. Element som ska läggas till i arrayen. Om du inte anger något element, kommer splice() helt enkelt att ta bort element från arrayen.

Returvärde Beskrivning

Om antalet specificerade element som ska infogas skiljer sig från antalet element som ska tas bort, kommer matrisen att ändra längd efter anropet.

Låt arr = ["Barca", "Shakhtar", "Manchester United", "Milan", "Real", "Ajax", "Juventus"]; låt nax = arr.splice(2, 3); arr.splice(2, 3); console.log(nax); // → ["Manchester United", "Milan", "Real"] console.log(arr); // → ["Barca", "Shakhtar"] arr.splice(1, 0, "Zenit", "CSKA", "Spartak"); console.log(arr); // → [Barça, Zenit, CSKA, Spartak, Shakhtar]

omvänd

Metoden reverse() vänder ordningen på arrayelementen. Som ett resultat blir det första elementet i arrayen det sista, och det sista elementet blir det första.

Låt arr = ; console.log(arr.reverse()); // → console.log(["Alice", "BG", "GO", "DDT"].reverce()); // → ["DDT", "GO", "BG", "Alice"]

Karta

Map()-metoden går igenom elementen i arrayen, utför specificerade åtgärder på dem och returnerar en kopia av arrayen med de ändrade elementen.

I exemplet nedan lägger vi till indexvärdet för detta element till varje matriselement (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

Låt arr = ; låt testMap = arr.map((element, index) => element + index); console.log(testMap); //

eller multiplicera varje värde i arrayen, till exempel med 12

Låt arr = ; låt testMap = arr.map(a => a * 12); console.log(testMap); // →

filtrera

Metoden filter() används för att filtrera arrayer. Den itererar genom arrayen och returnerar endast de element som klarar ett givet villkor.

Låt oss till exempel filtrera värdena för en array av siffror, så att endast de som är större än 21

Låt arr = ; låt testFilter = arr.filter(element => element > 21); console.log(testFilter); // →

Observera att 21 inte inkluderades i arrayresultatet, eftersom villkoret var att returnera något som är större än 21. För att 21 ska inkluderas i arrayen anger vi villkoret som större än eller lika med: element >= 21

minska

Metoden reduce() går sekventiellt igenom elementen i arrayen och ackumuleras mellanresultat enligt den funktion som anges i funktionens tillstånd. I slutresultatet returnerar det bara ett värde.

Denna metod används ofta för att hitta summan av alla tal i en matris. Exempel:

Låt arr = ; let summa = arr.reduce((acc, element) => acc + element); console.log(summa); // → 370

sortera

Metoden sort() används för att sortera arrayelement enligt specificerade parametrar.

Exempel – låt oss ta en uppsättning siffror och sortera dem i stigande ordning:

Låt arr = ; låt testSortArr = arr.sort((a, b) => a - b); console.log(testSortArr); // →

inkluderar

Metoden include() avgör om arrayen innehåller specifikt element, returnerar sant eller falskt beroende på detta.

Exempel på användning av include() .

Här är ett logiskt uttryck:

Låt djur = "hund"; if (djur == "katt" || djur == "hund" || djur == "lejon" || djur == "häst") ( // ........ )

Med inkluderingsmetoden kan du skriva det så här:

Låt djur = "hund"; const animals = ["katt", "hund", "lejon", "häst"]; if (djur.inkluderar(djur)) ( // ........... )