Käivitage ülaltoodud kood. Saate tellimuse 1, 15, 2. Seda seetõttu, et meetod teisendab kõik stringiks ja kasutab vaikimisi leksikograafilist järjekorda.

Eelmises artiklis rääkisime sellest, mis see on ja kuidas sellega töötada. Selles artiklis räägime mitmemõõtmeline massiiv.

See on massiiv, millel on üks või mitu elementi, mis on samuti massiivid. Sõltuvalt reklaami sügavusest võib seda nimetada kahemõõtmeline massiiv(2 taset) kolmemõõtmeline massiiv(3 taset) neljamõõtmeline(4 taset) ja nii edasi.

Pärast ühemõõtmelist massiivi on kõige populaarsem kahemõõtmeline massiiv. Uurime seda üksikasjalikumalt.

Nagu näete, on kahemõõtmelise massiivi elemendid ühemõõtmelised massiivid. Kui need ühemõõtmelised massiivid sisaldaksid rohkem massiive, oleks arr-massiiv juba kolmemõõtmeline.

Näiteks loome kolm lihtsat massiivi ja täidame need andmetega. Esimese täidame paarisarvudega, teise paarituga ja kolmanda suvaliste andmetega.

// Deklareeri kolm tühja massiivi var evenNumbers = new Massiiv (); // Muutuja k - massiiviindeksite puhul paarisarvud var k = 0; var oddNumbers = new Massiiv (); // Muutuja n - massiiviindeksite puhul paaritu arv var n = 0; var andmed = uus massiiv ("auto", "lennuk", tõsi, 89, "m"); // Täitke massiiv paarisarvudega paarisarvudega (var i = 1; i

Selleks, et näha, mis massiivi sees on, võite kasutada sellist tööriista nagu konsool.

Näiteks tahame näha paaritu arvuga massiivi oddNumbers sisu. Selleks kirjutage allolevasse koodi järgmine rida:

Console.log (paarituid numbreid);

Tulemuse nägemiseks peate avama konsool brauseris... Google Chrome'is tehakse seda järgmiselt: paremklõpsake lehte ja valige kontekstimenüüst viimane suvand „Kuva kood”, see tähendab inspektor. Ingliskeelses versioonis nimetatakse seda valikut Inspect.

Ja allpool kuvatakse arendaja tööriistariba. Selles peate minema vahekaardile Konsool.

Nüüd selleks, et luua kahemõõtmeline massiiv, peate selle deklareerima ja sellele ülaloleva ühemõõtmelise massiivi lisama.

// Kuulutage kahemõõtmeline massiiv kaksDimens ja täitke see var twoDimens = new Massiiv (paarisarvud, paarituarvud, andmed); console.log (twoDimens);

Vaatame selle massiivi sisu konsoolis.

itereerides kahemõõtmelise massiivi kohal

Kõigepealt õpime kuidas pääseda juurde kahemõõtmelise massiivi elementidele.

Nagu üksikute massiivide puhul, pääseb elementidele juurde nende indeksite abil.

Näiteks näitame elementi indeksis 3 paaritu arvuga massiivist (paaritu arv). Ühemõõtmelise massiivi oddNumbers indeks kahemõõtmelises massiivis twoDimens on üks (1).

Document.write ("Element indeksiga 3 paaritu arvude massiivist paaritu arv on:" + twoDimens); Element: 7

Massiivis twoDimens viitame elemendile indeksis 1. Selle indeksi element on massiiv OddNumbers. Ja selles massiivis pääseme juba juurde elemendile indeksiga 3, mis on number 7.

Läheme nüüd küsimuse enda juurde kuidas itereerida kahemõõtmelises massiivis.

Loop üle kahemõõtmelise massiivi tehakse topelttsükli abil. Näiteks kordame oma kahe dimensiooni massiivi.

Sest (var i = 0; i< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("

Element indeksiga " + i +" " + j +" on võrdne: " + kaks dimensiooni [i] [j] +"

Esimeses silmus kordame üle kahe dimensiooni massiivi ise. Teises ahelas kordame juba elementi ennast (massiivi). Esiteks on muutuja i võrdne 0. Seetõttu teises tsüklis kordame esmalt üle esimese massiivi evenNumbers, mille indeks on 0. Ja juba teise ahela sees pääseme juurde selle massiivi elementidele. Seega: kahemõõtmelised [j]. Kus j on vahemikus 0 kuni massiivi paarisarvud.

Pärast esimese massiivi elementide itereerimist naaseme esimese silmuse juurde, suurendame muutujat i ja jätkame teise massiivi paaritu arvu üle, mille indeks on 1. Ja nii me kordame kahemõõtmelise massiivi iga elemendi üle kahemõõtmelised.

Vaatame nüüd selle otsingu tulemust:

See on kõik, millest ma selles artiklis rääkida tahtsin. Nüüd teate, kuidas luua kahemõõtmelist massiivi, kuidas pääseda juurde kahemõõtmelise massiivi elementidele ja kuidas kahemõõtmelisel massiivil itereerida. Loodan, et kõik oli selge. Soovin teile suurt edu!

Massiivid

Massiiv on tellitud väärtuste kogu. Massiivi väärtusi nimetatakse elementideks ja iga elementi iseloomustab massiivi numbriline asukoht, mida nimetatakse indeksiks. JavaScripti massiivid on kirjutamata: massiivi elemendid võivad olla mis tahes tüüpi ja sama massiivi erinevad elemendid võivad olla erinevat tüüpi. Massiivielemendid võivad olla isegi objektid või muud massiivid, mis võimaldab teil luua keerukaid andmestruktuure, näiteks objektide massiive ja massiivimassiive.

Massiiviindeksid JavaScriptis on nullpõhised ja kasutavad 32-bitiseid täisarvu-massiivi esimesel elemendil on indeks 0. JavaScripti massiivid on dünaamilised: nad võivad vastavalt vajadusele kasvada ja kahaneda; massiivide fikseeritud suurusi pole vaja deklareerida nende loomisel ega mälu ümberjaotamist nende suuruse muutmisel.

JavaScripti massiivid on objektide spetsiifiline vorm ja massiiviindeksid tähendavad midagi enamat kui lihtsalt atribuutide nimesid, mis juhuslikult on täisarvud.

Massiivide loomine

Lihtsaim viis massiivi loomiseks on literaal, mis on lihtne komaga eraldatud massiivielementide loend nurksulgudes. Massiivi literaali väärtused ei pea olema konstandid - need võivad olla mis tahes avaldised, sealhulgas objekti literaalid:

Var tühi =; // Tühi massiiv var arvud =; // Viie numbrilise elemendiga massiiv var misc = [1.1, true, "a",]; // 3 erinevat tüüpi elementi + lõppkoma var baas = 1024; var tabel =; // Massiiv muutujatega var arrObj = [,]; // 2 massiivi, mis sisaldavad objekte

Massiivi sõnasõnaline süntaks võimaldab sisestada valikulise lõppkoma, s.t. literaalne [,] sobib massiivi kahe elemendiga, mitte kolmega.

Teine võimalus massiivi loomiseks on konstruktori kutsumine Massiiv ()... Konstruktorit saab helistada kolmel erineval viisil:

Helistage konstruktorile ilma argumentideta:

Var arr = uus massiiv ();

Sel juhul luuakse tühi massiiv, mis on samaväärne literaaliga.

Helistage konstruktorile ühe numbrilise argumendiga, mis määrab massiivi pikkuse:

Var arr = uus massiiv (10);

Sel juhul luuakse määratud pikkusega tühi massiiv. Seda Array () konstruktori kutsumise vormi saab kasutada massiivi mälu eeljaotamiseks, kui selle elementide arv on ette teada. Pange tähele, et see ei salvesta massiivi ühtegi väärtust.

Määrake selgesõnaliselt kahe esimese või enama massiivielemendi või ühe mittearvulise elemendi väärtused konstruktorikutses:

Var arr = uus massiiv (5, 4, 3, 2, 1, "test");

Sel juhul saavad konstruktori argumentidest uue massiivi elementide väärtused. Massiivi literaalide kasutamine on peaaegu alati lihtsam kui Array () konstruktori kasutamine sel viisil.

Massiivi elementide lugemine ja kirjutamine

Massiivielementidele pääseb juurde operaatori abil. Sulgudes vasakul peab olema massiivi viide. Sulgudes peab olema suvaline avaldis, mis tagastab mitte-negatiivse täisarvu. See süntaks sobib nii massiivielemendi väärtuse lugemiseks kui ka kirjutamiseks. Seetõttu kehtivad kõik järgmised JavaScripti avaldused:

// Ühe elemendiga massiivi loomine var arr = ["maailm"]; // Loe üksust 0 var väärtus = arr; // Kirjutage väärtus elemendile 1 arr = 3,14; // Kirjutage väärtus elemendile 2 i = 2; arr [i] = 3; // Väärtuse kirjutamine elemendile 3 arr = "tere"; // Loe punkte 0 ja 2, kirjuta väärtus punkti 3 arr] = arr;

Tuletan teile meelde, et massiivid on spetsialiseeritud objekt. Massiivielementide juurde pääsemiseks kasutatavad nurksulud toimivad täpselt samamoodi nagu nurksulud, mida kasutatakse objekti omadustele juurdepääsemiseks. JavaScripti tõlk teisendab sulgudes olevad numbrilised indeksid stringideks - indeks 1 muutub stringiks "1" - ja kasutab seejärel stringe atribuutide nimedena.

Numbriliste indeksite stringideks teisendamisel pole midagi erilist: sama saab teha ka tavaliste objektidega:

Var obj = (); // Loo lihtne objekt obj = "üks"; // Indeksige see täisarvudega

Massiivide eripära on see, et kui kasutatakse atribuutide nimesid, mis ei ole negatiivsed täisarvud, määravad massiivid automaatselt selle väärtuse pikkus... Näiteks ülalpool loodi massiiv arr ühe elemendiga. Seejärel määrati selle elementidele väärtused indeksitega 1, 2 ja 3. Nende toimingute tulemusel muutus massiivi pikkuse omaduse väärtus ja sai võrdseks 4 -ga.

Peaksite selgelt eristama massiivi indekseid objekti omaduste nimedest. Kõik indeksid on atribuutide nimed, kuid ainult täisarvuliste nimedega atribuudid on indeksid. Kõik massiivid on objektid ja saate neile atribuute lisada mis tahes nimega. Kui aga puudutate atribuute, mis on massiiviindeksid, reageerivad massiivid vajadusel pikkuse atribuudi väärtust värskendades.

Pange tähele, et negatiivsed ja mitte täisarvud on lubatud massiiviindeksitena. Sellisel juhul teisendatakse numbrid stringideks, mida kasutatakse omaduste nimedena.

Massiivielementide lisamine ja eemaldamine

Oleme juba näinud, et lihtsaim viis massiivi elementide lisamiseks on väärtuste määramine uutele indeksitele. Seda meetodit saate kasutada ka massiivi lõppu ühe või mitme elemendi lisamiseks lükkama ():

Var arr =; // Loo tühi massiiv arr.push ("null"); // Lisa lõppu väärtus arr.push ("üks", 2); // Lisage veel kaks väärtust

Massiivi lõppu saate lisada ka elemendi, määrates arr -elemendile väärtuse. Elemendi sisestamiseks massiivi algusesse saate seda meetodit kasutada vahetamata () ja massiivi olemasolevad elemendid nihutatakse kõrgematele indeksitele.

Massiivi elemente saate kustutamisoperaatori abil kustutada, näiteks objektide tavalisi omadusi:

Var arr =; kustuta arr; 2 in arr; // vale, indeks 2 massiivis on määratlemata arr.length; // 3: kustutamisoperaator ei muuda massiivi pikkuse omadust

Elemendi eemaldamine on sarnane (kuid veidi erinev), määrates sellele elemendile määratlemata väärtuse. Pange tähele, et kustutusoperaatori rakendamine massiivi elemendile ei muuda pikkuse atribuudi väärtust ega nihuta kõrgemate indeksitega elemente allapoole, et täita tühimik, mis jääb pärast elemendi kustutamist.

Lisaks on võimalik massiivi lõpus olevaid elemente eemaldada, omistades lihtsalt pikkuse omadusele uue väärtuse. Massiividel on meetod pop ()(vastupidine tõukele ()), mis vähendab massiivi pikkust 1 võrra ja tagastab eemaldatud elemendi väärtuse. Samuti on olemas meetod vahetus ()(vastupidine unshift ()), mis eemaldab massiivi alguses oleva elemendi. Erinevalt kustutusoperaatorist nihutab shift () meetod kõiki elemente nende praegustest indeksitest allapoole.

Lõpuks on mitmeotstarbeline meetod liitmine (), mis võimaldab massiivi elemente sisestada, kustutada ja asendada. See muudab pikkuse omaduse väärtust ja nihutab massiivi elemente vastavalt vajadusele madalamate või kõrgemate indeksitega. Me arutame kõiki neid meetodeid veidi hiljem.

Mitmemõõtmelised massiivid

JavaScript ei toeta "päris" mitmemõõtmelisi massiive, kuid teeb head tööd nende jäljendamiseks massiivide massiivide abil. Massiivi massiivi andmeüksusele juurdepääsemiseks piisab operaatori kahekordsest kasutamisest.

Oletame näiteks, et muutuv maatriks on numbrimassiivide massiiv. Iga maatriksi [x] element on arvude massiiv. Massiivi kindlale numbrile juurdepääsemiseks saate kasutada avaldismaatriksit [x] [y]. Allpool on konkreetne näide, kus korrutustabelina kasutatakse kahemõõtmelist massiivi:

// Loo mitmemõõtmeline massiiv var tabel = new Massiiv (10); // Tabelis on 10 rida (var i = 0; i

Massiivi klassi meetodid

ECMAScript 3 standard määratleb Array.prototype osana massiividega töötamiseks palju mugavaid funktsioone, mis on saadaval mis tahes massiivi meetoditena. Neid meetodeid tutvustatakse järgmistes alajaotistes.

Liitu () meetod

Meetod Array.join () teisendab kõik massiivi elemendid stringideks, ühendab need ja tagastab saadud stringi. Valikulise argumendi saab meetodile edastada stringiga, mida kasutatakse tulemuste stringi üksuste eraldamiseks. Kui eraldaja stringi pole määratud, kasutatakse koma. Näiteks järgneva katkendi tulemuseks on string "1,2,3":

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

Pöördmeetod ()

Meetod Array.reverse () muudab massiivi elementide järjekorda ja tagastab ümberjärjestatud massiivi. Permutatsioon toimub otse algsel massiivil, st. see meetod ei loo uut massiivi ümberkorraldatud elementidega, vaid järjestab need juba olemasolevasse massiivi. Näiteks järgmine katkend, mis kasutab meetodit reverse () ja join (), annab stringi "3,2,1":

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

Sortimise () meetod

Meetod Array.sort () sorteerib algse massiivi elemendid ja tagastab sorteeritud massiivi. Kui sort () meetodit kutsutakse argumentideta, sorteeritakse tähestikulises järjekorras (võrdluseks teisendatakse üksused vajadusel ajutiselt stringideks). Määratlemata elemendid mähitakse massiivi lõpuni.

Võid anda võrdlusfunktsiooni argumendina, et sortida (), et sortida mis tahes muus mitte-tähestikulises järjekorras. See funktsioon määrab, milline kahest argumendist peaks sorteeritud loendis olema esimene. Kui esimene argument peab eelnema teisele, peab võrdlusfunktsioon tagastama negatiivse arvu. Kui esimene argument peab sorteeritud massiivis järgima teist, peab funktsioon tagastama nullist suurema arvu. Ja kui need kaks väärtust on samaväärsed (st nende järjekord pole oluline), peaks võrdlusfunktsioon tagastama 0:

Var arr =; arr.sort (); // Tähestikulises järjekorras: 1111, 222, 33, 4 arr.sort (funktsioon (a, b) (// Numbrijärjestus: 4, 33, 222, 1111 return ab; // Tagastab väärtuse 0 // olenevalt liigist tellige a ja b)); // Sorteeri tagurpidi, kõrgeimast madalaimani arr.sort (funktsioon (a, b) (tagastab b-a));

Pange tähele, kui mugav on selles väljavõttes kasutada nimetut funktsiooni. Võrdlusfunktsiooni kasutatakse ainult siin, seega pole vaja sellele nime anda.

Konkati () meetod

Meetod Array.concat () loob ja tagastab uue massiivi, mis sisaldab algse massiivi elemente, millel kutsuti meetodit concat () ja mis tahes argumentide väärtused edastati meetodile concat (). Kui mõni neist argumentidest on ise massiiv, lisatakse selle elemendid tagastatud massiivi. Tuleb aga märkida, et massiivi ei ole rekursiivselt teisendatud massiividest ühemõõtmeliseks. Meetod concat () ei muuda algset massiivi. Allpool on mõned näited:

Var arr =; arr.concat (4, 5); // Tagastab arr.concat (); // tagastab arr.concat (,) // tagastab arr.concat (4,]) // tagastab]

Viil () meetod

Meetod Array.slice () tagastab määratud massiivi viilu või alammassiivi. Meetodi kaks argumenti määravad tagastatud tüki alguse ja lõpu. Tagastatud massiiv sisaldab esimeses argumendis nummerdatud elementi ja kõiki järgnevaid elemente kuni (kuid mitte) teise argumendiga nummerdatud elemendini.

Kui on määratud ainult üks argument, sisaldab tagastatud massiiv kõiki elemente massiivi alguspositsioonist lõpuni. Kui mõni argument on negatiivne, määrab see elemendi numbri massiivi lõpu suhtes. Niisiis, argument -1 vastab massiivi viimasele elemendile ja argument -3 vastab massiivi kolmandale elemendile lõpust. siin on mõned näidised:

Var arr =; arr.viil (0,3); // Tagastab arr.slice (3); // Tagastab arr.slice (1, -1); // Tagastab arr.slice (-3, -2); // Tuleb tagasi

Splice () meetod

Meetod Array.splice () on üldine meetod, mis lisab või eemaldab massiivist elemente. Erinevalt meetoditest slice () ja concat () muudab splice () meetod algset massiivi, millel seda kutsuti. Pange tähele, et splice () ja slice () meetoditel on väga sarnased nimed, kuid nad täidavad täiesti erinevaid toiminguid.

Splice () meetod võib eemaldada massiivist elemente, lisada uusi elemente või teha mõlemat korraga. Massiivi elemente nihutatakse vastavalt vajadusele, nii et pärast sisestamist või kustutamist moodustuks külgnev järjestus.

Splice () meetodi esimene argument määrab massiivi asukoha, kust see sisestada ja / või kustutada. Teine argument määrab massiivist eemaldatavate (lõigatud) elementide arvu. Kui teine ​​argument välja jätta, eemaldatakse kõik massiivi elemendid määratud massiivist massiivi lõpuni. Splice () meetod tagastab eemaldatud elementide massiivi või (kui ühtegi elementi pole eemaldatud) tühja massiivi.

Splice () meetodi kaks esimest argumenti määravad eemaldatavad massiivielemendid. Nendele argumentidele võib järgneda suvaline arv täiendavaid argumente, mis määravad massiivi lisatavad elemendid, alustades esimeses argumendis määratud positsioonist.

Var arr =; arr.plice (4); // Tagastab arr = arr.splice (1,2); // Tagastab arr = arr.splice (1,1); // Tuleb tagasi; arr = arr =; arr.splice (2,0, "a", "b"); // Tuleb tagasi; arr =

Push () ja pop () meetodid

Push () ja pop () meetodid võimaldavad massiive kohelda virnadena. Push () meetod lisab massiivi lõppu ühe või mitu uut elementi ja tagastab selle uue pikkuse. Pop () meetod sooritab vastupidise toimingu - eemaldab massiivi viimase elemendi, vähendab massiivi pikkust ja tagastab eemaldatud väärtuse. Pange tähele, et mõlemad meetodid muudavad algset massiivi, mitte ei loo sellest muudetud koopiat.

Shift () ja shift () meetodid

Meetodid unshift () ja shift () käituvad samamoodi nagu push () ja pop (), välja arvatud see, et need lisavad ja eemaldavad elemente massiivi alguses, mitte lõpus. Meetod unshift () nihutab olemasolevad elemendid suuremate indeksite poole, et ruumi teha, lisab elemendi või elemendid massiivi algusesse ja tagastab massiivi uue pikkuse. Shift () meetod eemaldab ja tagastab massiivi esimese elemendi, nihutades kõik järgnevad elemendid ühe koha võrra allapoole, et hõivata massiivi alguses vabanenud ruum.

Viimane uuendus: 09.04.2018

Massiivid on mõeldud andmekogumitega töötamiseks. Massiivi loomiseks kasutatakse avaldist new Array ():

Var myArray = uus massiiv ();

Massiivi lähtestamiseks on ka lühem viis:

Var myArray =;

Sel juhul loome tühja massiivi. Kuid saate sellele lisada ka lähteandmeid:

Var inimesed = ["Tom", "Alice", "Sam"]; console.log (inimesed);

Sel juhul on myArray'is kolm elementi. Graafiliselt saab seda esitada järgmiselt:

Indekseid kasutatakse massiivi üksikutele elementidele viitamiseks. Loendamine algab nullist, see tähendab, et esimesel elemendil on indeks 0 ja viimasel indeks 2:

Var inimesed = ["Tom", "Alice", "Sam"]; console.log (inimesed); // Tom var person3 = inimesed; // Sam console.log (isik3); // Sam

Kui proovime pääseda juurde elemendile, mille indeks on suurem kui massiivi suurus, saame määratlemata:

Var inimesed = ["Tom", "Alice", "Sam"]; console.log (inimesed); // määratlemata

Samuti määratakse indeksiga massiivi elementide väärtused:

Var inimesed = ["Tom", "Alice", "Sam"]; console.log (inimesed); // Tom inimesed = "Bob"; console.log (inimesed); // Bob

Lisaks saate erinevalt teistest keeltest, näiteks C # või Java, installida elemendi, mida algselt ei installitud:

Var inimesed = ["Tom", "Alice", "Sam"]; console.log (inimesed); // määratlemata - massiivis on ainult kolm elementi people = "Bob"; console.log (inimesed); // Bob

Samuti väärib märkimist, et erinevalt paljudest JavaScripti programmeerimiskeeltest pole massiive tugevasti trükitud, saab ühte massiivi salvestada erinevat tüüpi andmeid:

Var objektid = ["Tom", 12, tõsi, 3,14, vale]; console.log (objektid);

levitaja

Laiendusoperaator ... võimaldab teil väärtusi massiivist eraldi võtta:

Olgu numbrid =; console.log (... numbrid); // 1 2 3 4 console.log (numbrid); //

Laotamise operaator on määratud massiivi ees. Selle tulemusena tagastab avaldis ... numbrid arvukomplekti, kuid see ei ole massiiv, vaid individuaalsed väärtused.

Mitmemõõtmelised massiivid

Massiivid võivad olla ühemõõtmelised ja mitmemõõtmelised. Iga mitmemõõtmelise massiivi element võib olla eraldi massiiv. Eespool kaalusime ühemõõtmelist massiivi, loome nüüd mitmemõõtmelise massiivi:

Var arvud1 =; // ühemõõtmeline massiiv var numbrid2 = [,]; // kahemõõtmeline massiiv

Visuaalselt saab mõlemat massiivi kujutada järgmiselt:

Ühemõõtmelised massiivi numbrid

Massiivi ühe elemendi saamiseks kasutatakse ka indeksit:

Var tomInfo = inimesed;

Alles nüüd kujutab muutuja tomInfo massiivi. Elemendi pesastatud massiivi sisenemiseks peame kasutama selle teist mõõdet:

Console.log ("Nimi:" + inimesed); // Tom console.log ("Vanus:" + inimesed); 25

See tähendab, et kui suudame kahemõõtmelist massiivi tabeli kujul visuaalselt kujutada, viitab element element tabeli lahtrile, mis asub esimese rea ja teise veeru ristumiskohas (esimene mõõde on 0 - rida, teine ​​mõõde - 1 - veerg).

Samuti saame ülesande täita:

Var inimesed = [["Tom", 25, vale], ["Bill", 38, tõsi], ["Alice", 21, vale]]; inimest = 56; // määrata eraldi väärtus console.log (people); // 56 inimest = ["Bob", 29, vale]; // massiivi määramine console.log (people); // Bob

Mitmemõõtmeliste massiivide loomisel ei piirdu me ainult kahemõõtmeliste massiividega, vaid võime kasutada ka suurte mõõtmetega massiive:

Var arvud =; numbrid =; // nüüd numbrid on kahemõõtmeline massiiv number =; // nüüd numbrid on kolmemõõtmeline massiiv arvud = 5; // 3D -massiivi esimene element on 5 console.log (numbrid);

Tervitused kõigile, kes on huvitatud JavaScripti mitmemõõtmelistest massiividest ja sortimisest. Käesolevas väljaandes püüan seda teemat üksikasjalikult käsitleda.

Seetõttu saate pärast selle artikli lugemist teada, miks veebirakendustes kasutatakse mitmemõõtmelisi massiive, kuidas neid luuakse ja kuidas nendega manipuleerida ja sorteerida. Hakkame õppima!

Kuidas luuakse mitmemõõtmelisi massiive ja milleks need on mõeldud?

Alustuseks tasub meeles pidada, kuidas luuakse tavaline ühemõõtmeline massiiv.

var massiiv =

Pidage nüüd meeles, et mitmemõõtmeline massiiv on massiivide massiiv. Olen nõus, see kõlab nagu tautoloogia. Lugege siiski määratlust uuesti. Tõepoolest, mitmemõõtmeline massiiv koosneb teatud hulgast pesastatud massiividest.

Kaaluge järgmist olukorda. Mängu alguses sisestab kasutaja oma nime ja pärast lõppu kuvatakse ekraanile mängijate nimede ja nende rekorditega reitingutabel.

On selge, et selline teave salvestatakse andmebaasi. Aga kui me selle andmebaasist välja tõmbame, saame mitmemõõtmelise massiivi. Lõppude lõpuks sisaldab iga alammass mängija sisselogimist ja kogutud punktide arvu.

See kõik näeb välja selline:

var tulemused = [["Markus", 333], ["Nataša", 211], ["Aleksei", 124]];

Nagu näete, saab teavet salvestada heterogeenselt. See võib olla stringid, numbrid ja isegi. See on võimalik, kuna massiivid on sisestamata.

Sellisel juhul toimub juurdepääs elementidele topeltoperaatori kaudu.

Materjali konsolideerimiseks analüüsige väikest programmi.

Tulemused =

Massiivid on üsna mugav viis tellitud keeruliste andmete salvestamiseks nende töötlemise ajal. Lisaks on nendega väga mugav töötada ja samal ajal on nende töötlemise kiirus üsna suur.

Andmete sortimise meetodid

JavaScripti massiivide jaoks on sisseehitatud meetod nimega sorteerima ()... See tööriist on väga paindlik. Ja nüüd ma selgitan, miks.

Kui kasutate parameetriteta meetodit, tellib see alammassiivid automaatselt tähestikulises järjekorras esimese elemendi järgi. Niisiis, helistades tulemused.sorteerima () sõelutud objekt näeb välja selline:

Aleksei, 124

Markus, 333

Nataša, 211

Ja kui vahetate iga pesastatud massiivi elemendid, saate:

124, Aleksei

211, Nataša

333, Markus

Sel juhul muudetakse võrdlemiseks kõik elemendid ajutiselt stringideks.

Kui konkreetse ülesande lahendamiseks vajate funktsiooni, mis sorteerib elemente mittestandardsel viisil, saate selle ise kirjutada ja edastada parameetrina sorteerima ()... Tuleb meeles pidada, et kasutaja määratud funktsioon peab tagastama:

• positiivne arv (üldiselt valige 1), kui esimene täpsustatud element järgneb võrdluses teisele;
• negatiivne arv (tavaliselt -1), kui teine ​​valitud üksus peaks järgima esimest;
• null, kui kaks testitud väärtust on võrdsed.

Näitena võtame esialgse massiivi tulemused sorteeri punktide järgi. Lisaks sorteeritakse tulemused kõrgeimast madalaimani. Seda saab teha kahel viisil.

Esimeses versioonis muutsin sortimisloogikat, s.t. olukorras, kus on vaja tagastada positiivne arv, annan tagasi negatiivse ja vastupidi.

Rekorditabel:

Kuid teise meetodi puhul jätsin sorteerimisloogika puutumata, kuid kasutasin lisaks teist meetodit - tagurpidi ()... Nagu nimigi ütleb, muudab tagurpidi elementide järjekord.

Seetõttu näeb sort () funktsioon välja selline:

funktsioon RecordSort (a, b) (kui (a> b) tagastab 1; muidu kui (a< b) return -1; else return 0; }

Pärast seda lisame ülaltoodud meetodi.

Järeldus tehakse sarnaselt.

Tahan juhtida teie tähelepanu ühele olulisele asjaolule. Nende funktsioonide kasutamisel toimuvad kõik muudatused massiivis, millele te neid rakendate. Seega, kui teil on vaja andmete esialgne vorm säilitada, looge koopia ja muutke seda.

Noh, nii et ma rääkisin mitmemõõtmelistest massiividest ja nende sorteerimisest. Kui teile artikkel meeldis, tellige ajaveeb ja lugege teisi sama huvitavaid väljaandeid. Oleksin repostide eest tänulik. Järgmise korrani!

Headaega!

Parimate soovidega, Roman Chueshov