Arrays i javascript i enkle ord. Sortering af array-elementer - sorter

Lad os lære at indeksere arrays i js, fjerne og tilføje deres elementer.

Et array i JavaScript er globalt objekt, designet til at gemme en liste over værdier.

Det ligner andre variabler, idet det kan gemme enhver type data. Men en matrix har en vigtig forskel fra en variabel: den kan gemme mere end ét element ad gangen.

Et array er en ordnet samling af værdier. Hver værdi kaldes et element og har sit eget tal, kaldet et indeks.

Et element inde i et array kan være af enhver type. Desuden kan elementerne i et array være forskellige typer: tal, strenge, logiske porte og endda objekter eller andre arrays.

Rækkefølgen af array-elementer starter fra 0. Det viser sig, at arrayet altid vil have et indeks forskudt med én: det første element vil have indeks 0, det andet 1 osv.

Her er et eksempel på et array med elementer af forskellige typer:

Oprettelse (erklærer) et array

Arrays er meget praktiske, fordi de kan gemme så mange data, som du har brug for. Den maksimalt mulige størrelse af et js-array er 2 32 elementer.

Vi skal fortælle JavaScript, at vi vil oprette et array. Der er to muligheder for dette: værdien i firkantede parenteser eller søgeord ny.

Kort notation: Brug af firkantede parenteser

En kommasepareret liste over værdier omgivet af firkantede parenteser.

var myArray = [ "Jack", "Sawyer", "John", "Desmond" ];

Indholdet af arrayet bestemmes af, hvad der er mellem firkantede parenteser. Hver værdi er adskilt af et komma.

Værdier angives på samme måde som simple variabler, det vil sige, at strenge skal erklæres omsluttet af anførselstegn osv.

For at erklære et tomt array skal du lade parenteserne være tomme:

var myArray = ;

Lang indtastning: ved hjælp af Array()-konstruktøren

var lostArray = new Array("Jack", "Sawyer", "John", "Desmond"); var twinPeaksArray = new Array("Laura", 2, ["Bob", "Leland", "Dale"]);

Det nye søgeord fortæller JavaScript om at oprette et nyt array, hvis værdier videregives som parametre.

Hvis du på forhånd ved, hvor mange elementer der vil være i dit array, kan du straks sende denne værdi i konstruktøren.

var myArray = new Array(80);

Ovenstående udtryk vil skabe et tomt array bestående af 80 slots med udefinerede værdier.

Erklærer et tomt array:

var myArray = new Array();

Adgang til Array Elements

Ved at bruge indekset for hvert element kan du arbejde med alle data i arrayet, få adgang til det ved hjælp af operatoren:

var myArray = ["Jack", "Sawyer", "John", "Desmond"]; console.log(myArray); // Udskriver "Jack" console.log(myArray); // Udskriver "Desmond"

Et array kan have flere niveauer, det vil sige, at hvert element i sig selv kan være et array. Resultatet bliver et todimensionelt js-array. Hvordan kan vi få adgang til disse arrays, der er placeret inde i andre - "multidimensionale arrays"?

Lad os som et eksempel betragte et array, der repræsenterer en familie. Børn fra denne familie er optaget i et separat array inde i hovedfamilien:

var familyArray = ["Marge", "Homer", ["Bart", "Lisa", "Maggie"]];

Du kan forestille dig det sådan her:

For at henvise til værdien "Lisa":

var lisa = familyArray; console.log(lisa); // udskriver "Lisa"

Dette kan fortsættes næsten på ubestemt tid, hvilket giver dig mulighed for at gemme indlejrede datasæt i arrays og få adgang til dem ved hjælp af indekser.

Tilføjelse af elementer til en matrix

Vi fandt ud af, hvordan man får adgang til array-elementer ved hjælp af deres tilsvarende indekser. På lignende måde kan du tilføje (eller ændre) elementer ved at angive, for eksempel:

var myArray = ["Kate", "Sun"]; myArray = "Juliet"; console.log(myArray); // Udskriver "Kate, Sun, Juliet"

Hvad sker der, hvis jeg erklærer et element med et indeks, der ikke har andre elementer før sig? Selve arrayet vil skabe alle de manglende elementer og tildele dem værdien undefined:

var myArray = ["Kate", "Sun"]; myArray = "Juliet"; console.log(myArray.length); // Udskriver "6" console.log(myArray); // Udskriver ["Kate", "Sung", udefineret, udefineret, udefineret, "Juliet"]

Du kan finde ud af, hvad længden af et js-array er ved at bruge egenskaben length. I eksemplet ovenfor er der seks elementer i arrayet, og tre af dem har ikke fået en værdi - de er markeret som udefinerede .

push() metode

Ved at bruge push()-metoden kan du tilføje et eller flere elementer til et js-array. Push() accepterer et ubegrænset antal parametre, som alle vil blive tilføjet til slutningen af arrayet.

var myArray = ["Kate", "Sut"]; myArray.push("Juliet"); // Tilføjer elementet "Juliet" til slutningen af arrayet myArray.push("Libby", "Shannon"); // Tilføjer elementerne "Libby" og "Shannon" til slutningen af arrayet console.log(myaArray); ); // Printer ["Kate", "Soon", "Juliet", "Libby", "Shannon"]

unshift() metode

Unshift()-metoden fungerer på samme måde som push(), bortset fra at den tilføjer elementer til begyndelsen af arrayet.

var myArray = ["Kate", "Sun"]; myArray.unshift("Juliet"); // Tilføjer elementet "Juliet" til begyndelsen af arrayet myArray.unshift("Libby", "Shannon"); // Tilføjer elementerne "Libby" og "Shannon" til begyndelsen af arrayet console.log(myArray); // Udgange ["Libby", "Shannon", "Juliet", "Kate", "Son"]

Fjernelse af matrixelementer Pop() og shift() metoder

Metoderne pop() og shift() fjerner henholdsvis det sidste og første element i et array:

var myArray = ["Jack", "Sawyer", "John", "Desmond", "Kate"]; myArray.pop(); // Fjerner "Kate"-elementet myArray.shift(); // Fjerner "Jack"-elementet console.log(myArray); // Udskriver ["Sawyer", "John", "Desmond"]

splice() metode

Ved hjælp af splejsningsmetode() kan du fjerne eller tilføje elementer til et array, mens du præcist angiver elementernes indeks.

Følgende eksempel bruger metoden splice() til at tilføje to elementer, startende ved indeks 2 (det vil sige det tredje element):

var fruitArray = ["æble", "fersken", "appelsin", "citron", "lime", "kirsebær"]; fruitArray.splice(2, 0, "melon", "banan"); console.log(fruitArray); // Udgange ["æble", "fersken", "melon", "banan", "appelsin", "citron", "lime", "kirsebær"]

Den første parameter i splice()-metoden er indekset. Den angiver på hvilken position elementer skal tilføjes/fjernes. I vores eksempel valgte vi indeks 2 (med værdien "orange").

Den anden parameter er antallet af elementer, der skal fjernes. Vi har angivet en værdi på 0, så intet vil blive slettet.

Følgende parametre er valgfrie. De tilføjer nye værdier til arrayet. I vores tilfælde skal vi tilføje "melon" og "banan", begyndende med indeks 2.

Arrays er en af de mest almindeligt anvendte typer variabler, der giver dig mulighed for at gemme mange sekventielle værdier på "et sted." Men når det kommer til JavaScript, er der plads til forbedringer.

I denne artikel vil vi se på tre lidt kendte teknikker, der kan bruges, når du arbejder med arrays.

1. Tilføjelse tilpassede egenskaber til arrays

Hvis du bruger en søgning til at finde JavaScript-definitionen af et array, vil de fleste kilder angive det denne type Værdien af en variabel er repræsenteret som et objekt.

Generelt set er mange af de ting, vi støder på i JavaScript, objekter. Det ville være rimeligt at bemærke, at sproget også indeholder "primitive" datatyper, men deres værdier bruges på en eller anden måde i egenskaber inde i objekter.

2. Adgang til array-elementer i en loop

Da matrixindekser kun kan tage positive værdier, starter optællingen fra nul. Vi kan senere bruge dette indeks til at få adgang til array-elementet ved en given loop-iteration.

ECMAScript6 introducerede en måde at rulle gennem et array uden at bruge indekser, men gennem en ny for...of-løkke.

For...of-løkken er designet til at iterere gennem elementerne i et array uden at påvirke elementets indeks.

Var ary = ["appelsin","æble","litchi"]; for (lad vare af ary)( console.log(item); ) // "orange", "æble", "lychee" Til sammenligning: udlæsning af vareindekser i en for-løkke. var ary = ["appelsin","æble","litchi"]; for (var item = 0; item< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Antallet af elementer er ikke dimensionen af arrayet

Når vi taler om størrelsen af et array, tænker vi normalt på det som antallet af elementer, der er gemt i det. Det er faktisk ikke helt rigtigt – længdeegenskaben beregnes afhængigt af maksimalt indeks element.

Længdeegenskaben er meget tvetydig. For at bekræfte dette skal du blot se på følgende manipulationer:

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

I sidste eksempel det var nok at sætte elementet i den femte position, som et resultat af hvilket længden af arrayet blev 6. Hvis du tror, at indekser fra 0 til 4 vil blive oprettet automatisk, vil du tage fejl. Dette kan kontrolleres ved hjælp af in-operatøren.

Var ary = ; ary.længde = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 i ary); // falsk

I I dette tilfælde Det er rimeligt at kalde den ary-array for "sparsom".

Vi kan også manipulere egenskaben længde for at trimme arrays. Eksemplet nedenfor viser "tabet" af elementet ved indeks 5 ved at reducere værdien længde egenskaber række ary.

Var ary = ; ary.længde = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 ary.length = 2; console.log(ary.length); // 2 console.log(ary); // udefineret

I denne lektion vil vi stifte bekendtskab med arrays, lære at skabe dem, udføre operationer på deres elementer og også se på de grundlæggende metoder og egenskaber, der er tilgængelige, når du arbejder med dem.

Array koncept

Et array er en ordnet samling af data, der har et navn og er en forekomst af et Array-objekt. Den består af elementer, der tilgås ved hjælp af deres serienummer(indeks). Nummereringen af elementer i en matrix starter ikke fra 1, men fra 0.

Følgende figur viser et numerisk array bestående af 7 elementer. Elementer af dette array indeholde følgende data: 1 element (0 indeks) - nummer 123, 2 element (1 indeks) - nummer 214, 3 element (2 indeks) - nummer 315 osv.

//element, som vi vil udlæse arrayet i //opretter et numerisk array var numberArray = new Array(123,214,315,312,124,206,218); //output arrayet til elementet med id="myP" document.getElementById("myP").innerHTML = "1 Array-element: " + numberArray + "
" + "2 Array-element: " + numberArray + "
" + "3 Array-element: " + numberArray + "
" + "4 Array-element: " + numberArray + "
" + "5 Array-element: " + numberArray + "
" + "6 Array-element: " + numberArray + "
" + "7 Array-element: " + numberArray;

Oprettelse (erklærer) et array

Oprettelse af et array på JavaScript udført vha operatør ny og Array-konstruktørfunktioner. Du kan angive en af følgende værdier inden for parentesen af Array-konstruktørfunktionen:

Nummer. I dette tilfælde denne funktion vil oprette en matrix bestående af det angivne antal elementer. Alle disse elementer vil have værdien undefined.
Flere værdier adskilt af kommaer. I dette tilfælde vil Array-konstruktørfunktionen oprette en matrix bestående af det angivne antal elementer og tildele dem de relevante værdier.
Ikke noget. I dette tilfælde vil denne funktion skabe et tomt array.

I modsætning til mange andre programmeringssprog ændrer arrays i JavaScript automatisk deres størrelse, dvs. de er i sagens natur dynamiske. Sådanne arrays behøver ikke gives nogen dimensioner. En til særpræg JavaScript-arrays er det i forskellige elementer det samme array kan indeholde Forskellige typer data.

Arbejde med Array Elements

For at kontakte specifikt element array, skal du angive navnet på dette array og dets indeks i firkantede parenteser. Denne operation også kaldet en indekseringsoperation.

Lad os for eksempel oprette et tomt array og tilføje 4 tekstelementer til det:

//oprettelse af et tomt array smartphoneColors var smartphoneColors = new Array(); //tildel 1 element i arrayet (indeks 0) værdien "Sort" smartphoneColors = "Sort"; //tildel det 2. array-element (indeks 1) til værdien "White" smartphoneColors = "White"; //tildel det 3. array-element (indeks 2) til værdien "Grey" smartphoneColors = "Grå"; //tildel det 4. element i arrayet (indeks 3) til værdien "Blue" smartphoneColors = "Blue";

Lad os for eksempel vise værdierne for 2 og 4 elementer i smartphoneColors-arrayet til browserkonsollen (F12):

Console.log("2 element = " + smartphoneColors); console.log("4 element = " + smartphoneColors);

Array længde (antal elementer i arrayet)

Bestemmelse af antallet af elementer i et array udføres ved hjælp af egenskaben length.

//opret et array ved at angive værdierne af elementerne i Array-funktionen var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //tildel lengthArray-variablen til længden af volumeHDDs-arrayet var lengthArray = volumeHDDs.length;

Sådan får du det første element i et array

At få værdien af det første element i et array gøres ved at angive tallet 0 i firkantede parenteser af dette array:

//oprettelse af et array bestående af 3 elementer var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //henter værdien af det første element i arrayet var firstValue = volumeHDD'er;

Sådan får du det sidste element i et array

At få værdi sidste element array udføres ved at angive udtrykket array_name.length-1 i firkantede parenteser af dette array:

//oprettelse af et array bestående af 3 elementer var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //henter værdien af det sidste element i arrayet var lastValue = volumeHDD'er;

Iteration over et array

Iteration gennem array-elementer udføres ved hjælp af for sløjfe.

Lad os for eksempel gentage alle elementerne i arrayet og vise deres værdier i browserkonsollen (F12):

//oprettelse af et array navnStudenter, bestående af 4 elementer var nameStudents = new Array("Petya","Vasya","Kolya","Maxim"); //iterate array-elementer fra 0 til array-længde-1 for (var i=0; i