Palaidiet iepriekš minēto kodu. Jūs saņemsiet pasūtījumu 1, 15, 2. Tas ir tāpēc, ka metode visu pārvērš virknē un izmanto noklusējuma leksikogrāfisko secību.

Iepriekšējā rakstā mēs runājām par to, kas tas ir un kā ar to strādāt. Šajā rakstā mēs runāsim par daudzdimensiju masīvs.

Tas ir masīvs, kurā ir viens vai vairāki elementi, kas arī ir masīvi. Jo īpaši atkarībā no reklāmas dziļuma to var izsaukt divdimensiju masīvs(2 līmeņi) trīsdimensiju masīvs(3 līmeņi) četrdimensiju(4 līmeņi) un tā tālāk.

Vispopulārākais pēc viendimensiju masīva, kas visbiežāk tiek izmantots, ir divdimensiju masīvs. Mēs to izpētīsim sīkāk.

Kā redzat, divdimensiju masīva elementi ir viendimensiju masīvi. Ja šajos viendimensiju masīvos būtu vairāk masīvu, tad arr masīvs jau būtu trīsdimensiju.

Piemēram, izveidosim trīs vienkāršus masīvus un aizpildīsim tos ar datiem. Pirmo aizpildīsim ar pāra skaitļiem, otro - ar nepāra skaitļiem, bet trešo - ar dažiem patvaļīgiem datiem.

// Deklarēt trīs tukšus masīvus var evenNumbers = new Array (); // Mainīgais k - masīva indeksiem evenNumbers var k = 0; var nepāra numuri = jauns masīvs (); // Mainīgais n - masīva indeksiem nepāraNumbers var n = 0; var dati = new Array ("auto", "lidmašīna", tiesa, 89, "m"); // Aizpildiet masīvu evenNumbers ar pāra skaitļiem (var i = 1; i

Lai redzētu, kas atrodas masīvā, varat izmantot šādu rīku kā konsole.

Piemēram, mēs vēlamies redzēt masīva saturu ar nepāra skaitļiem oddNumbers. Lai to izdarītu, zemāk esošajā kodā ierakstiet šādu rindu:

Console.log (nepāra numuri);

Lai redzētu rezultātu, jums ir jāatver konsole pārlūkprogrammā... Pārlūkprogrammā Google Chrome tas tiek darīts šādi: ar peles labo pogu noklikšķiniet uz lapas un konteksta izvēlnē atlasiet pēdējo opciju “Skatīt kodu”, tas ir, inspektoru. Angļu valodas versijā šo opciju sauc par Pārbaudīt.

Un zemāk parādīsies izstrādātāja rīkjosla. Tajā jums jāiet uz cilni Konsole.

Tagad, lai izveidot divdimensiju masīvu, jums tas jādeklarē un jāpievieno tam iepriekš izveidotie viendimensiju masīvi.

// Deklarēt divdimensiju masīvu twoDimens un aizpildīt to var twoDimens = new Array (pāra numuri, nepāra skaitļi, dati); console.log (twoDimens);

Apskatīsim šī masīva saturu konsolē.

atkārtojot divdimensiju masīvu

Pirmkārt, iemācīsimies kā piekļūt divdimensiju masīva elementiem.

Tāpat kā atsevišķiem masīviem, elementiem piekļūst to indeksi.

Piemēram, parādīsim elementu 3. indeksā no masīva ar nepāra skaitļiem (nepāra skaitļi). Viendimensiju masīva oddNumbers indekss divdimensiju masīvā twoDimens ir viens (1).

Document.write ("Elements ar indeksu 3 no nepāra skaitļu masīva oddNumbers ir:" + diviDimens); // Elements: 7

Masīvā twoDimens mēs atsaucamies uz elementu 1. indeksā. Šī indeksa elements ir nepāra skaitļu masīvs. Un šajā masīvā mēs jau piekļūstam elementam ar indeksu 3, kas ir skaitlis 7.

Tagad ķersimies pie paša jautājuma kā atkārtot divdimensiju masīvu.

Cilpa virs divdimensiju masīva tiek veikta, izmantojot dubultu cilpu. Piemēram, atkārtosim mūsu divu dimensiju masīvu.

Attiecībā uz (var i = 0; i< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("

Elements ar indeksu " + i +" " + j +" ir vienāds ar: " + divi izmēri [i] [j] +"

Pirmajā cilpā mēs atkārtojam pašu masīvu twoDimens. Otrajā cilpā mēs jau atkārtojam pašu elementu (masīvu). Pirmkārt, mainīgais i ir vienāds ar 0. Tāpēc otrajā cilpā vispirms atkārtojam pirmo masīvu evenNumbers, kuram ir indekss 0. Un jau otrās cilpas iekšpusē mēs piekļūstam šī masīva elementiem. Tādējādi: twoDimens [j]. Kur j svārstās no 0 līdz pāra skaitļu masīva garumam.

Pēc iterācijas pār pirmā masīva elementiem mēs atgriežamies pirmajā cilpā, palielinām mainīgo i un turpinām atkārtot otro masīvu nepāra skaitļi, kuram ir indekss 1. Un tā mēs atkārtojam katru divdimensiju masīva elementu twoDimens.

Tagad apskatīsim šīs meklēšanas rezultātu:

Tas ir viss, par ko es gribēju runāt šajā rakstā. Tagad jūs zināt, kā izveidot divdimensiju masīvu, kā piekļūt divdimensiju masīva elementiem un kā atkārtot divdimensiju masīvu. Ceru, ka viss bija skaidrs. Es novēlu jums lielus panākumus!

Masīvi

Masīvs ir sakārtota vērtību kolekcija. Masīva vērtības sauc par elementiem, un katru elementu raksturo skaitliska pozīcija masīvā, ko sauc par indeksu. JavaScript masīvi ir netipiski: masīva elementi var būt jebkura veida, un viena un tā paša masīva dažādi elementi var būt dažāda veida. Masīva elementi var būt pat objekti vai citi masīvi, kas ļauj izveidot sarežģītas datu struktūras, piemēram, objektu masīvus un masīvu masīvus.

Masīva indeksi JavaScript ir balstīti uz nulli un izmanto 32 bitu veselus skaitļus-masīva pirmajam elementam ir indekss 0. JavaScript masīvi ir dinamiski: tie var augt un sarukt pēc vajadzības; nav nepieciešams deklarēt fiksētu izmēru masīvus, kad tie tiek izveidoti, vai atkārtoti piešķirt atmiņu, kad tie tiek mainīti.

JavaScript masīvi ir specializēta objektu forma, un masīvu indeksi nozīmē ne tikai īpašumu nosaukumus, kas nejauši ir veseli skaitļi.

Masīvu izveide

Vieglākais veids, kā izveidot masīvu, ir ar burtu, kas ir vienkāršs ar komatiem atdalīts masīva elementu saraksts kvadrātiekavās. Masīva literāļa vērtībām nav jābūt konstantēm - tās var būt jebkuras izteiksmes, tostarp objektu literāļi:

Var tukšs =; // Tukšs masīvs var numuri =; // Masīvs ar pieciem ciparu elementiem var misc = [1.1, true, "a",]; // 3 dažāda veida elementi + beigu komats var bāze = 1024; var tabula =; // Masīvs ar mainīgajiem var arrObj = [,]; // 2 masīvi, kas satur objektus

Masīva burtiskā sintakse ļauj ievietot neobligātu beigu komatu, t.i. literal [,] atbilst masīvam ar diviem, nevis trim elementiem.

Vēl viens veids, kā izveidot masīvu, ir izsaukt konstruktoru Masīvs ()... Konstruktoru var izsaukt trīs dažādos veidos:

Zvaniet konstruktoram bez argumentiem:

Var arr = jauns masīvs ();

Šajā gadījumā tiks izveidots tukšs masīvs, kas ekvivalents literālam.

Izsauciet konstruktoru ar vienu ciparu argumentu, norādot masīva garumu:

Var arr = jauns masīvs (10);

Šajā gadījumā tiks izveidots tukšs norādītā garuma masīvs. Šo Array () konstruktora izsaukšanas veidu var izmantot, lai iepriekš piešķirtu masīvam atmiņu, ja tā elementu skaits ir zināms iepriekš. Ņemiet vērā, ka masīvā netiek saglabātas nekādas vērtības.

Konstruktoru izsaukumā skaidri norādiet pirmo divu vai vairāku masīva elementu vai viena neciparu elementa vērtības:

Var arr = jauns masīvs (5, 4, 3, 2, 1, "tests");

Šajā gadījumā konstruktora argumenti kļūst par jaunā masīva elementu vērtībām. Masīva literālu lietošana gandrīz vienmēr ir vieglāka nekā šādā veidā izmantojot Array () konstruktoru.

Masīva elementu lasīšana un rakstīšana

Masīva elementiem var piekļūt, izmantojot operatoru. Iekavās pa kreisi jābūt masīva atsaucei. Iekavās jābūt patvaļīgai izteiksmei, kas atgriež veselu skaitli, kas nav negatīvs. Šī sintakse ir piemērota gan masīva elementa vērtības lasīšanai, gan rakstīšanai. Tāpēc visi šie JavaScript paziņojumi ir derīgi:

// Izveidot masīvu ar vienu elementu var arr = ["pasaule"]; // Lasīt vienumu 0 var vērtība = arr; // Ierakstiet vērtību elementam 1 arr = 3,14; // Ierakstiet vērtību elementā 2 i = 2; arr [i] = 3; // Ierakstiet vērtību elementam 3 arr = "sveiki"; // Izlasiet vienumus 0 un 2, ierakstiet vērtību vienumam 3 arr] = arr;

Atgādināšu, ka masīvi ir specializēts objektu veids. Kvadrātiekavas, ko izmanto, lai piekļūtu masīva elementiem, darbojas tieši tāpat kā kvadrātiekavas, ko izmanto, lai piekļūtu objekta īpašībām. JavaScript tulks konvertē iekavās esošos skaitliskos indeksus par virknēm - indekss 1 kļūst par virkni "1" - un pēc tam izmanto virknes kā rekvizītu nosaukumus.

Ciparu indeksu pārvēršana par virknēm nav nekas īpašs: to pašu var izdarīt ar parastajiem objektiem:

Var obj = (); // Izveidot vienkāršu objektu obj = "viens"; // Indeksējiet to ar veseliem skaitļiem

Masīvu īpatnība ir tāda, ka, izmantojot rekvizītu nosaukumus, kas nav negatīvi veseli skaitļi, masīvi automātiski nosaka īpašuma vērtību garums... Piemēram, arr masīvs tika izveidots iepriekš ar vienu elementu. Pēc tam tā elementiem tika piešķirtas vērtības ar indeksiem 1, 2 un 3. Šo darbību rezultātā masīva garuma rekvizīta vērtība mainījās un kļuva vienāda ar 4.

Jums skaidri jānošķir masīva indeksi un objekta rekvizītu nosaukumi. Visi indeksi ir īpašumu nosaukumi, bet indeksi ir tikai rekvizīti ar veseliem skaitļiem. Visi masīvi ir objekti, un tiem varat pievienot rekvizītus ar jebkuru nosaukumu. Tomēr, ja pieskaraties īpašumiem, kas ir masīvu indeksi, masīvi reaģē, pēc vajadzības atjauninot garuma rekvizīta vērtību.

Ņemiet vērā, ka negatīvi un veseli skaitļi ir atļauti kā masīva indeksi. Šajā gadījumā skaitļi tiek pārvērsti virknēs, kuras tiek izmantotas kā rekvizītu nosaukumi.

Masīva elementu pievienošana un noņemšana

Mēs jau esam redzējuši, ka vienkāršākais veids, kā pievienot masīvam elementus, ir piešķirt vērtības jauniem indeksiem. Varat arī izmantot šo metodi, lai masīva beigās pievienotu vienu vai vairākus elementus spiest ():

Var arr =; // Izveidojiet tukšu masīvu arr.push ("nulle"); // Pievienojiet vērtību beigām arr.push ("viens", 2); // Pievienojiet vēl divas vērtības

Jūs varat arī pievienot elementu masīva beigām, piešķirot arr elementam vērtību. Lai ievietotu elementu masīva sākumā, varat izmantot šo metodi nemainīgs () un esošie masīva elementi tiek pārvietoti uz augstākiem indeksiem.

Jūs varat dzēst masīva elementus, izmantojot dzēšanas operatoru, piemēram, parastās objektu īpašības:

Var arr =; izdzēst arr; 2 in arr; // false, indekss 2 masīvā ir nenoteikts arr.length; // 3: dzēšanas operators nemaina masīva garuma rekvizītu

Elementa noņemšana ir līdzīga (bet nedaudz atšķirīga), piešķirot šim elementam nenoteiktu vērtību. Ņemiet vērā, ka dzēšanas operatora piemērošana masīva elementam nemaina garuma rekvizīta vērtību, kā arī nepārvietojas lejup pa augstāk indeksētajiem elementiem, lai aizpildītu tukšumu, kas palicis pēc elementa dzēšanas.

Turklāt ir iespējams noņemt elementus masīva beigās, vienkārši piešķirot garuma rekvizītam jaunu vērtību. Masīviem ir metode pop ()(pretēji push ()), kas samazina masīva garumu par 1 un atgriež noņemtā elementa vērtību. Ir arī metode maiņa ()(pretēji unshift ()), kas noņem elementu masīva sākumā. Atšķirībā no dzēšanas operatora, shift () metode novirza visus elementus uz leju par vienu pozīciju zem to pašreizējiem indeksiem.

Visbeidzot, ir daudzfunkcionāla metode savienojums (), kas ļauj ievietot, dzēst un aizstāt masīvu elementus. Tas maina garuma rekvizīta vērtību un pēc vajadzības maina masīva elementus ar zemākiem vai augstākiem indeksiem. Visas šīs metodes mēs apspriedīsim nedaudz vēlāk.

Daudzdimensiju masīvi

JavaScript neatbalsta "īstus" daudzdimensiju masīvus, taču tas labi paveic to atdarināšanu, izmantojot masīvus no masīviem. Lai piekļūtu datu vienumam masīvu masīvā, pietiek ar operatora divreizēju izmantošanu.

Piemēram, pieņemsim, ka mainīgā matrica ir skaitļu masīvu masīvs. Katrs matricas [x] elements ir skaitļu masīvs. Jūs varat izmantot izteiksmes matricu [x] [y], lai piekļūtu konkrētam masīva skaitlim. Tālāk ir sniegts konkrēts piemērs, kur divdimensiju masīvs tiek izmantots kā reizināšanas tabula.

// Izveidot daudzdimensiju masīvu var tabula = new Array (10); // Tabulā ir 10 rindas (var i = 0; i

Masīvu klases metodes

ECMAScript 3 standarts nosaka daudzas ērtas funkcijas darbam ar masīviem kā daļu no Array.prototype, kas ir pieejamas kā jebkura masīva metodes. Šīs metodes tiks parādītas turpmākajās apakšnodaļās.

Pievienoties () metode

Metode Array.join () pārvērš visus masīva elementus par virknēm, saista tos un atgriež iegūto virkni. Neobligātu argumentu metodei var nodot ar virkni, kas tiks izmantota rezultātu virknes elementu atdalīšanai. Ja norobežojošā virkne nav norādīta, tiek izmantots komats. Piemēram, pēc šī fragmenta tiek iegūta virkne "1,2,3":

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

Reversā () metode

Array.reverse () metode maina masīva elementu secību un atgriež pārkārtotu masīvu. Permutācija tiek veikta tieši sākotnējā masīvā, t.i. šī metode neveido jaunu masīvu ar pārkārtotiem elementiem, bet pārkārto tos jau esošā masīvā. Piemēram, šāds fragments, kurā tiek izmantotas metodes reverse () un join (), iegūst virkni "3,2,1":

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

Kārtošanas () metode

Metode Array.sort () kārto sākotnējā masīva elementus un atgriež sakārtoto masīvu. Ja kārtošanas () metode tiek izsaukta bez argumentiem, kārtošana tiek veikta alfabētiskā secībā (salīdzinājumam, ja nepieciešams, vienumi tiek īslaicīgi pārvērsti virknēs). Nedefinēti elementi tiek iesaiņoti masīva beigās.

Jūs varat nodot salīdzināšanas funkciju kā argumentu, lai kārtotu (), lai kārtotu jebkurā citā alfabētiskā secībā. Šī funkcija nosaka, kuriem no diviem argumentiem sakārtotajā sarakstā jābūt pirmajiem. Ja pirmajam argumentam jābūt pirms otrā, salīdzināšanas funkcijai jāatgriež negatīvs skaitlis. Ja pirmajam argumentam ir jāseko otrajam sakārtotajā masīvā, funkcijai jāatgriež skaitlis, kas lielāks par nulli. Un, ja abas vērtības ir līdzvērtīgas (t.i., to secībai nav nozīmes), salīdzināšanas funkcijai jāatgriež 0:

Var arr =; arr.sort (); // Alfabētiskā secība: 1111, 222, 33, 4 arr.sort (funkcija (a, b) (// Ciparu secība: 4, 33, 222, 1111 return ab; // Atgriež vērtību 0 // atkarībā no kārtošanas pasūtīt a un b)); // Kārtot atpakaļ, no augstākā līdz zemākajam arr.sort (funkcija (a, b) (atgriešanās b-a));

Ievērojiet, cik ērti šajā fragmentā ir izmantot nenosauktu funkciju. Salīdzināšanas funkcija tiek izmantota tikai šeit, tāpēc nav jāpiešķir tai nosaukums.

Konkata () metode

Metode Array.concat () izveido un atgriež jaunu masīvu, kas satur sākotnējā masīva elementus, uz kuriem tika izsaukta metode concat (), un visu argumentu vērtības, kas tika nodotas concat () metodei. Ja kāds no šiem argumentiem ir masīvs, tā elementi tiek pievienoti atgrieztajam masīvam. Tomēr jāatzīmē, ka masīvs netiek rekursīvi pārveidots no masīviem uz viendimensiju masīvu. Metode concat () nemaina sākotnējo masīvu. Zemāk ir daži piemēri:

Var arr =; arr.concat (4, 5); // Atgriež arr.concat (); // Atgriež arr.concat (,) // Atgriež arr.concat (4,]) // Atgriež]

Šķēles () metode

Metode Array.slice () atgriež norādītā masīva šķēli vai apakšmasu. Abi metodes argumenti nosaka atgrieztās daļas sākumu un beigas. Atgrieztajā masīvā ir elements, kas numurēts pirmajā argumentā, kā arī visi nākamie elementi līdz (bet neieskaitot) otrā argumenta numurēto elementu.

Ja ir norādīts tikai viens arguments, atgrieztais masīvs satur visus elementus no sākuma pozīcijas līdz masīva beigām. Ja kāds no argumentiem ir negatīvs, tas norāda elementa numuru attiecībā pret masīva beigām. Tātad arguments -1 atbilst masīva pēdējam elementam, un arguments -3 atbilst masīva trešajam elementam no beigām. Šeit ir daži piemēri:

Var arr =; arr.šķēle (0,3); // Atgriež arr.slice (3); // Atgriež arr.slice (1, -1); // Atgriež arr.slice (-3, -2); // Atgriezīsies

Splice () metode

Array.splice () metode ir vispārīga metode, kas ievieto vai noņem masīva elementus. Atšķirībā no slice () un concat () metodēm, splice () metode maina sākotnējo masīvu, uz kura tā tika izsaukta. Ņemiet vērā, ka savienošanas () un šķēles () metodēm ir ļoti līdzīgi nosaukumi, taču tās veic pilnīgi atšķirīgas darbības.

Splice () metode var noņemt elementus no masīva, ievietot jaunus elementus vai veikt abus vienlaikus. Masīva elementi tiek pārvietoti pēc vajadzības, lai pēc ievietošanas vai dzēšanas tiktu izveidota blakus esoša secība.

Pirmais splice () metodes arguments norāda atrašanās vietu masīvā, no kuras ievietot un / vai dzēst. Otrais arguments norāda no masīva noņemamo (izgriežamo) elementu skaitu. Ja otrais arguments tiek izlaists, visi masīva elementi no norādītā masīva līdz masīva beigām tiek noņemti. Splice () metode atgriež noņemto elementu masīvu vai (ja neviens no elementiem nav noņemts) tukšu masīvu.

Pirmie divi splice () metodes argumenti norāda noņemamos masīva elementus. Šiem argumentiem var sekot jebkurš papildu arguments, norādot elementus, kas jāievieto masīvā, sākot ar pirmajā argumentā norādīto pozīciju.

Var arr =; šķēle (4); // Atgriež arr = arr.splice (1,2); // Atgriež arr = arr.splice (1,1); // Atgriezīsies; arr = arr =; arr.splice (2,0, "a", "b"); // Atgriezīsies; arr =

Push () un pop () metodes

Push () un pop () metodes ļauj strādāt ar masīviem, piemēram, kaudzēm. Push () metode pievieno vienu vai vairākus jaunus elementus masīva beigām un atgriež tā jauno garumu. Pop () metode veic pretēju darbību - tā noņem masīva pēdējo elementu, samazina masīva garumu un atgriež noņemto vērtību. Ņemiet vērā, ka abas šīs metodes maina sākotnējo masīvu, nevis izveido tā modificētu kopiju.

Unhift () un shift () metodes

Metodes unshift () un shift () darbojas tādā pašā veidā kā push () un pop (), izņemot to, ka tās ievieto un noņem elementus masīva sākumā, nevis beigās. Metode unshift () novirza esošos elementus uz lielākiem indeksiem, lai atbrīvotu vietu, pievieno elementu vai elementus masīva sākumam un atgriež jauno masīva garumu. Shēma () noņem un atgriež masīva pirmo elementu, novirzot visus nākamos elementus uz leju par vienu pozīciju, lai aizņemtu masīva sākumā atbrīvoto vietu.

Pēdējais atjauninājums: 09.04.2018

Masīvi ir paredzēti darbam ar datu kopām. Masīva izveidei tiek izmantota izteiksme new Array ():

Var myArray = jauns masīvs ();

Ir arī īsāks veids, kā inicializēt masīvu:

Var myArray =;

Šajā gadījumā mēs izveidojam tukšu masīvu. Bet tam var pievienot arī sākotnējos datus:

Var cilvēki = ["Toms", "Alise", "Sems"]; console.log (cilvēki);

Šajā gadījumā myArray būs trīs elementi. Grafiski to var attēlot šādi:

Indeksus izmanto, lai atsauktos uz atsevišķiem masīva elementiem. Skaitīšana sākas no nulles, tas ir, pirmajam elementam būs indekss 0, bet pēdējam - indekss 2:

Var cilvēki = ["Toms", "Alise", "Sems"]; console.log (cilvēki); // Tom var person3 = cilvēki; // Sam console.log (person3); // Sems

Ja mēs mēģinām piekļūt elementam ar indeksu, kas lielāks par masīva lielumu, mēs iegūstam nenoteiktu:

Var cilvēki = ["Toms", "Alise", "Sems"]; console.log (cilvēki); // nenoteikts

Turklāt ar indeksu tiek iestatītas masīva elementu vērtības:

Var cilvēki = ["Toms", "Alise", "Sems"]; console.log (cilvēki); // Tom people = "Bobs"; console.log (cilvēki); // Bobs

Turklāt atšķirībā no citām valodām, piemēram, C # vai Java, jūs varat instalēt elementu, kas sākotnēji nebija instalēts:

Var cilvēki = ["Toms", "Alise", "Sems"]; console.log (cilvēki); // undefined - masīvā ir tikai trīs elementi people = "Bob"; console.log (cilvēki); // Bobs

Ir arī vērts atzīmēt, ka atšķirībā no vairākām JavaScript programmēšanas valodām masīvi nav stingri drukāti, vienā masīvā var saglabāt dažāda veida datus:

Dažādi objekti = ["Tom", 12, true, 3,14, false]; console.log (objekti);

izkliedētāja operators

Izkliedēšanas operators ... ļauj atsevišķi ņemt vērtības no masīva:

Ļaujiet skaitļiem =; console.log (... skaitļi); // 1 2 3 4 console.log (skaitļi); //

Izkliedēšanas operators ir norādīts pirms masīva. Rezultātā izteiksme ... numuri atgriezīs skaitļu kopu, taču tas nebūs masīvs, bet atsevišķas vērtības.

Daudzdimensiju masīvi

Masīvi var būt viendimensiju un daudzdimensiju. Katrs daudzdimensiju masīva elements var būt atsevišķs masīvs. Iepriekš mēs uzskatījām par viendimensiju masīvu, tagad izveidosim daudzdimensiju masīvu:

Var skaitļi1 =; // viendimensiju masīvs var numuri2 = [,]; // divdimensiju masīvs

Vizuāli abus masīvus var attēlot šādi:

Viendimensiju masīva numuri

Lai iegūtu vienu masīva elementu, tiek izmantots arī indekss:

Var tomInfo = cilvēki;

Tikai tagad mainīgais tomInfo pārstāvēs masīvu. Lai iegūtu elementu ligzdotā masīvā, mums jāizmanto tā otrā dimensija:

Console.log ("Nosaukums:" + cilvēki); // Tom console.log ("Vecums:" + cilvēki); 25

Tas ir, ja mēs varam vizuāli attēlot divdimensiju masīvu tabulas veidā, tad elements cilvēki atsaucas uz tabulas šūnu, kas atrodas pirmās rindas un otrās kolonnas krustojumā (pirmā dimensija ir 0 - rinda, otrā dimensija - 1 - kolonna).

Mēs varam arī veikt uzdevumu:

Var cilvēki = [["Tom", 25, false], ["Bill", 38, true], ["Alice", 21, false]]; cilvēki = 56; // piešķirt atsevišķu vērtību console.log (people); // 56 cilvēki = ["Bobs", 29, nepatiess]; // piešķirt masīvu console.log (people); // Bobs

Veidojot daudzdimensiju masīvus, mēs neaprobežojamies tikai ar divdimensiju masīviem, bet varam izmantot arī lielu izmēru masīvus:

Var skaitļi =; skaitļi =; // tagad skaitļi ir divdimensiju masīva skaitļi =; // tagad skaitļi ir trīsdimensiju masīva skaitļi = 5; // 3D masīva pirmais elements ir 5 konsole.log (skaitļi);

Sveiciens visiem, kurus interesē JavaScript daudzdimensiju masīvi un šķirošana. Pašreizējā publikācijā es centīšos aptvert šo tēmu visās detaļās.

Tāpēc, izlasot šo rakstu, jūs uzzināsit, kāpēc tīmekļa lietojumprogrammās tiek izmantoti daudzdimensiju masīvi, kā tie tiek izveidoti un kā ar tiem var manipulēt un kārtot. Sāksim mācīties!

Kā tiek veidoti daudzdimensiju masīvi un kam tie paredzēti?

Sākumā ir vērts atcerēties, kā tiek izveidots parasts viendimensiju masīvs.

var masīvs =

Tagad atcerieties, ka daudzdimensiju masīvs ir masīvu masīvs. Piekrītu, tas izklausās pēc tautoloģijas. Tomēr vēlreiz izlasiet definīciju. Patiešām, daudzdimensionāls masīvs sastāv no noteikta skaita ligzdotu.

Apsveriet šādu situāciju. Spēles sākumā lietotājs ievada savu vārdu, un pēc beigām ekrānā tiek parādīta vērtējumu tabula ar spēlētāju vārdiem un viņu ierakstiem.

Ir skaidrs, ka šāda informācija tiek glabāta datu bāzē. Bet, izvelkot to no datu bāzes, mēs iegūstam daudzdimensiju masīvu. Galu galā katrā apakšmasā ir spēlētāja pieteikšanās vārds un iegūto punktu skaits.

Tas viss izskatīsies šādi:

var rezultāti = [["Markus", 333], ["Nataša", 211], ["Aleksejs", 124]];

Kā redzat, informāciju var uzglabāt neviendabīgi. Tas var būt virknes, skaitļi un pat. Tas ir iespējams, jo masīvi ir netipiski.

Šajā gadījumā piekļuve elementiem notiek, izmantojot dubultu operatoru.

Lai konsolidētu materiālu, analizējiet nelielu programmu.

Rezultāti =

Masīvi ir diezgan ērts veids, kā uzglabāt pasūtītos sarežģītos datus, tos apstrādājot. Turklāt ar viņiem ir ļoti ērti strādāt, un tajā pašā laikā to apstrādes ātrums ir diezgan liels.

Datu šķirošanas metodes

JavaScript masīviem ir iebūvēta metode ar nosaukumu kārtot ()... Šis rīks ir ļoti elastīgs. Un tagad es paskaidrošu, kāpēc.

Ja izmantojat metodi bez parametriem, tā automātiski sakārto apakšmasas pēc pirmā elementa alfabētiskā secībā. Tātad, zvanot rezultātus.kārtot () parsētais objekts izskatīsies šādi:

Aleksejs, 124

Markus, 333

Nataša, 211

Un, mainot katra ligzdotā masīva elementus, jūs iegūstat:

124, Aleksejs

211, Nataša

333, Markus

Šajā gadījumā salīdzināšanai visi elementi tiek īslaicīgi pārveidoti par virknēm.

Ja konkrēta uzdevuma risināšanai jums ir nepieciešama funkcija, kas nestandarta veidā kārto elementus, tad varat to uzrakstīt pats un nodot kā parametru kārtot ()... Jāpatur prātā, ka pielāgotajai funkcijai ir jāatgriež:

• pozitīvs skaitlis (parasti izvēlieties 1), ja salīdzinājumā pirmais norādītais vienums seko otrajam;
• negatīvs skaitlis (parasti -1), ja otrajam atlasītajam vienumam jāseko pirmajam;
• nulle, ja abas pārbaudītās vērtības ir vienādas.

Kā piemēru ņemsim sākotnējo masīvu rezultātus kārtot pēc punktiem. Turklāt rezultāti tiks sakārtoti no augstākā līdz zemākajam. To var izdarīt divos veidos.

Pirmajā versijā es mainīju šķirošanas loģiku, t.i. situācijā, kad nepieciešams atgriezt pozitīvu skaitli, es atdodu negatīvu un otrādi.

Ierakstu tabula:

Bet otrajā metodē es atstāju neskartu šķirošanas loģiku, bet papildus izmantoju citu metodi - otrādi ()... Kā norāda nosaukums, reverss apgriež elementu secību.

Tāpēc funkcija sort () izskatīsies šādi:

funkcija RecordSort (a, b) (ja (a> b) atgriež 1; citādi, ja (a< b) return -1; else return 0; }

Pēc tam pievienosim iepriekš minēto metodi.

Secinājums tiek izdarīts līdzīgā veidā.

Es vēlos pievērst jūsu uzmanību vienam svarīgam punktam. Izmantojot šīs funkcijas, visas izmaiņas notiek masīvā, kuram tās lietojat. Tādējādi, ja jums ir jāsaglabā datu sākotnējā forma, izveidojiet kopiju un pēc tam rediģējiet to.

Nu, tāpēc es runāju par daudzdimensiju masīviem un to šķirošanu. Ja jums patika raksts, abonējiet emuāru un izlasiet citas tikpat interesantas publikācijas. Būšu pateicīgs par repostiem. Līdz nākamajai reizei!

Čau čau!

Ar cieņu, Romans Čušovs