JavaScript – masyvai. Masyvo elementų pertvarkymas atvirkštine tvarka – atvirkščiai

2017-06-21 12:17 val

Norėdami apskaičiuoti „JavaScript“ objektų masyvo dydį, naudokite masyvo ilgio savybę.

Var arr = ["pirmasis", "antrasis"]; console.log(arr.length); // 2

„Javascript“ masyvai gali turėti spragų savo indeksuose. Pavyzdžiui

Var arr = ; arr = "pirmasis"; arr = "antra";

Ilgio savybė grąžina maksimalų masyvo indeksą + 1. T.y. pateiktame pavyzdyje ilgis = 5.

Elementų skaičiaus masyve skaičiavimas javascript

Masyvas.prototype.count = funkcija()(var rezultatas = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }

Naudojimo pavyzdys

Var arr = ; arr = "pirmasis"; arr = "antra"; console.log(arr.count()); //2

Taip pat ilgio ypatybei galite priskirti vertę. Tai leidžia sumažinti esamo masyvo ilgį.

Var arr = ["pirmas", "antras", "trečias"]; arr.ilgis = 2; konsolės žurnalas(arr); // ["pirma sekundė"]

Masyvo dydžio baitais skaičiavimas javascript

Masyvai yra įprasti objektai, todėl masyvo dydžio apskaičiavimas baitais nesiskiria nuo bet kurio kito objekto dydžio skaičiavimo. Deja, javascript nepateikia API dydžiui apskaičiuoti, todėl turėsite jį apskaičiuoti patys. Tai daroma taip: apeiname visas objekto savybes, jei savybė yra primityviojo tipo, tokio tipo egzemplioriaus dydį pridedame prie bendro rezultato, jei savybėje yra objektas, rekursyviai apskaičiuojame jo dydis.

Funkcijos dydisOf(obj) ( var baitai = 0; if(obj !== null && obj !== neapibrėžta) ( jungiklis (obj tipas) ( atvejis "skaičius": baitai += 8; pertrauka; raidė "eilutė": baitai += obj.length * 2; pertrauka; didžioji raidė "bulio": baitai += 4; pertrauka; didžioji raidė "objektas": for(var key in obj) ( baitai += sizeOf(obj); ) break; ) ) grąžina baitus ; );

Metodas nėra tikslus ir turi daug problemų – pavyzdžiui, tikėtina, kad jis pateks į begalinę kilpą.

Paskutinis atnaujinimas: 2018-03-26

Masyvo objektas žymi masyvą ir suteikia daugybę savybių bei metodų, kuriais galime manipuliuoti masyvu.

Masyvo inicijavimas

Galima sukurti tuščią masyvą naudojant laužtiniai skliaustai arba masyvo konstruktorius:

varusers = naujas Masyvas(); var žmonės = ; konsolės žurnalas (vartotojai); // Masyvo konsolė.log(žmonės); // masyvas

Galite iš karto inicijuoti masyvą su tam tikru elementų skaičiumi:

Var vartotojai = new Array("Tomas", "Bill", "Alisa"); var people = ["Samas", "Jonas", "Kate"]; konsolės žurnalas (vartotojai); // ["Tomas", "Bill", "Alisa"] console.log(people); // ["Samas", "Džonas", "Kate"]

Galite apibrėžti masyvą ir į jį įtraukti naujus elementus.

varusers = naujas Masyvas(); vartotojai = "tom"; vartotojai = "kate"; konsolės žurnalas (vartotojai); // "Tomas" console.log(users); // neapibrėžtas

Nesvarbu, kad pagal numatytuosius nustatymus masyvas sukuriamas nulinio ilgio. Indeksų pagalba galime pakeisti konkretų masyvo indeksą vienu ar kitu elementu.

ilgio

Norėdami sužinoti masyvo ilgį, naudokite ilgio savybę:

var vaisius = naujas Array(); vaisiai = "obuoliai"; vaisiai = "kriaušės"; vaisiai = "slyvos"; document.write("Masyvo vaisiuose " + fruit.length + " elementas:
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Tiesą sakant, masyvo ilgis bus paskutinio elemento indeksas plius vienas. Pavyzdžiui:

varusers = naujas Masyvas(); // masyve yra 0 elementų vartotojai = "Tomas"; vartotojai = "kate"; vartotojai = "sam"; for(var i=0; i

Naršyklės išvestis:

Tom Kate 2020 Kitas Sam

Nors 2 ir 3 indeksų elementų nepridėjome, masyvo ilgis šiuo atveju bus skaičius 5. Tiesiog 2 ir 3 indeksų elementai turės reikšmę neapibrėžta .

Masyvo kopijavimas. gabalas ()

Masyvo kopijavimas gali būti seklus arba seklus (sekli kopija) ir gilus (gili kopija).

Sekliam kopijavimui pakanka kintamajam priskirti kito kintamojo, kuris saugo masyvą, reikšmę:

var users = ["Tomas", "Samas", "Bill"]; konsolės žurnalas (vartotojai); // ["Tomas", "Samas", "Bill"] var people = users; // sekliai kopijuoti žmonės = "Mike"; // pakeisti antrąjį elementą console.log(users); // ["Tomas", "Mike", "Bill"]

Šiuo atveju žmonių kintamasis, nukopijuotas, nurodys tą patį masyvą kaip ir vartotojų kintamasis. Todėl keičiant žmonių elementus, pasikeis ir vartotojų elementai, nes iš tikrųjų tai yra tas pats masyvas.

Toks elgesys ne visada pageidautinas. Pavyzdžiui, norime, kad po nukopijavimo kintamieji nukreiptų į atskirus masyvus. Ir šiuo atveju galite naudoti gilųjį kopijavimą naudodami slice() metodą:

var users = ["Tomas", "Samas", "Bill"]; konsolės žurnalas (vartotojai); // ["Tomas", "Samas", "Bill"] var people = users.slice(); // gilios kopijos žmonės = "Mike"; // pakeisti antrąjį elementą console.log(users); // ["Tomas", "Samas", "Bill"] console.log(people); // ["Tomas", "Mike", "Bill"]

Tokiu atveju po nukopijavimo kintamieji nurodys skirtingus masyvus, kuriuos galime keisti atskirai vienas nuo kito.

Be to, slice() metodas leidžia nukopijuoti dalį masyvo:

Var vartotojai = ["Tomas", "Samas", "Bill", "Alisa", "Kate"]; var žmonės = vartotojai.slice(1, 4); konsolės žurnalas (žmonės); // ["Samas", "Billas", "Alisa"]

Slice() metodui perduodamas pradžios ir pabaigos indeksas, kurie naudojami reikšmėms iš masyvo gauti. Tai reiškia, kad šiuo atveju pasirinkimas į naują masyvą pereina nuo 1 indekso iki 4, neįskaitant. Ir kadangi masyvo indeksavimas prasideda nuo nulio, naujame masyve bus antrasis, trečiasis ir ketvirtasis elementai.

stumti ()

Push () metodas prideda elementą į masyvo pabaigą:

var vaisius = ; vaisius.push("obuoliai"); vaisius.push("kriaušes"); vaisius.push("slyvos"); vaisius.push("vyšnia","abrikosas
"); document.write(vaisiai); // obuoliai, kriaušės, slyvos, vyšnios, abrikosai

pop ()

Pop () metodas pašalina paskutinį elementą iš masyvo:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos"]; var lastFruit = vaisiai.pop(); // gauti paskutinį elementą iš masyvo document.write(lastFruit + "
"); document.write("Masyvo vaisiuose " + fruit.length + " elementas:
"); for(var i=0; i ");

Naršyklės išvestis:

Slyvos Vaisių masyvą sudaro 2 elementai: obuoliai kriaušės

shift ()

Shift() metodas nuskaito ir pašalina pirmąjį elementą iš masyvo:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos"]; var firstVaisiai = vaisius.shift(); document.write(firstFruit + "
"); document.write("Masyvo vaisiuose " + fruit.length + " elementas:
"); for(var i=0; i ");

Naršyklės išvestis:

Obuoliai Vaisių masyvą sudaro 2 elementai: kriaušės slyvos

unshift ()

Metodas unshift() prideda naują elementą į masyvo pradžią:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos"]; vaisius.unshift("abrikosai"); dokumentas.rašyti(vaisius);

Naršyklės išvestis:

Abrikosai, obuoliai, kriaušės, slyvos

Elemento pašalinimas pagal indeksą. sandūra ()

Splice() metodas pašalina elementus iš konkretaus indekso. Pavyzdžiui, pašalinus elementus iš trečiojo indekso:

Var vartotojai = ["Tomas", "Samas", "Bill", "Alisa", "Kate"]; var deleted = vartotojai.splice(3); konsolės žurnalas (ištrintas); // [ "Alisa", "Kate" ] console.log(users); // [ "Tomas", "Samas", "Bill" ]

Pjūvio metodas grąžina pašalintus elementus.

Šiuo atveju ištrynimas atliekamas nuo masyvo pradžios. Jei išlaikysite neigiamą indeksą, pašalinimas bus atliktas nuo masyvo pabaigos. Pavyzdžiui, pašalinkime paskutinį elementą:

Var vartotojai = ["Tomas", "Samas", "Bill", "Alisa", "Kate"]; var deleted = vartotojai.splice(-1); konsolės žurnalas (ištrintas); // [ "Kate" ] console.log(users); // [ "Tomas", "Samas", "Billas", "Alisa" ]

Papildoma metodo versija leidžia nurodyti pabaigos indeksą, kurį norite ištrinti. Pavyzdžiui, pašalinkime nuo pirmo iki trečio indekso:

Var vartotojai = ["Tomas", "Samas", "Bill", "Alisa", "Kate"]; var deleted = vartotojai.splice(1,3); konsolės žurnalas (ištrintas); // [ "Samas", "Bill", "Alisa" ] console.log(users); // [ "Tomas", "Kate" ]

Kita sujungimo metodo versija leidžia vietoje pašalintų elementų įterpti naujus elementus:

Var vartotojai = ["Tomas", "Samas", "Bill", "Alisa", "Kate"]; var deleted = vartotojai.splice(1,3, "Ann", "Bob"); konsolės žurnalas (ištrintas); // [ "Samas", "Bill", "Alisa" ] console.log(users); // [ "Tomas", "Ann", "Bob", "Kate" ]

Šiuo atveju pašaliname tris elementus iš 1-ojo į 3-iojo indekso ir įterpiame du elementus.

concate ()

Concat() metodas naudojamas masyvams sujungti:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos"]; var vegetables = ["pomidorai", "agurkai", "bulvės"]; var produktai = vaisiai.concat(daržovės); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

Šiuo atveju nebūtina derinti tik to paties tipo masyvų. Taip pat galite turėti įvairių tipų:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos"]; įvairios kainos = ; var produktai = vaisiai.concat(kainos);

prisijungti ()

Join () metodas sujungia visus masyvo elementus į vieną eilutę:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos", "abrikosai", "persikai"]; var fruitString = vaisius.join(", "); document.write(fruitString);

Join() metodas perduodamas skyrikliu tarp masyvo elementų. Šiuo atveju kablelis ir tarpas (", ") bus naudojami kaip skyriklis.

Rūšiuoti ()

Sort() metodas rūšiuoja masyvą didėjančia tvarka:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos", "abrikosai", "persikai"]; vaisių rūšiavimas (); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Išvestis naršyklėje:

Abrikosai kriaušės persikai slyvos obuoliai

atvirkščiai ()

Reverse () metodas apverčia masyvą atgal:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos", "abrikosai", "persikai"]; vaisius.reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Išvestis naršyklėje:

Persikai Abrikosai Slyvos Kriaušės Obuoliai

Kartu su metodu sort() galite rūšiuoti masyvą mažėjančia tvarka:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos", "abrikosai", "persikai"]; vaisius.rūšiuoti().reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Išvestis naršyklėje:

Obuoliai slyvos persikai kriaušės abrikosai

Elemento indekso radimas

Metodai indexOf() ir lastIndexOf() grąžina pirmojo ir paskutinio masyvo elemento pasireiškimo indeksą. Pavyzdžiui:

Var vaisiai = ["obuoliai", "kriaušės", "slyvos", "obuoliai", "kriaušės"]; var firstIndex = vaisiai.indexOf("obuoliai"); var lastIndex = vaisiai.lastIndexOf("obuoliai"); var otherIndex = vaisiai.indexOf("vyšnios"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1

firstIndex yra 0, nes pirmasis eilutės "obuoliai" masyve yra 0, o paskutinis - 3.

Jei elemento nėra masyve, tada metodai indexOf() ir lastIndexOf() grąžina -1.

kiekvienas ()

Metodas every() patikrina, ar visi elementai atitinka tam tikrą sąlygą:

Variantų skaičiai = [ 1, -12, 8, -4, 25, 42 ]; funkcijos sąlyga(reikšmė, indeksas, masyvas) ( var rezultatas = false; if (reikšmė > 0) ( rezultatas = tiesa; ) grąžina rezultatą; ); var praėjo = skaičiai.kiekvienas(sąlyga); dokumentas.rašyti(išlaikytas); // netikras

Metodui every() perduodama funkcija, kuri sąlygą parodo kaip parametrą. Šiai funkcijai reikalingi trys parametrai:

Funkcijos sąlyga (reikšmė, indeksas, masyvas) ( )

Vertės parametras žymi dabartinį kartojamą masyvo elementą, indekso parametras – to elemento indeksą, o masyvo parametras perduoda nuorodą į masyvą.

Naudodami šią funkciją, galime patikrinti, ar elemento vertė yra perduota pagal tam tikras sąlygas. Pavyzdžiui, šiame pavyzdyje mes tikriname kiekvieną masyvo elementą, kad pamatytume, ar jis didesnis už nulį. Jei jis didesnis, tada grąžiname reikšmę true , tai yra, elementas atitinka sąlygą. Jei mažiau, grąžinkite false – elementas neatitinka sąlygos.

Dėl to, kai iškviečiamas numeriai.kiekvienas(sąlyga) metodas, jis kartojasi per visus skaičių masyvo elementus ir paeiliui perduoda juos sąlygos funkcijai. Jei ši funkcija grąžina true visiems elementams, tada every() grąžina true . Jei bent vienas elementas neatitinka sąlygos, metodas every() grąžina false .

kai kurie ()

Some() metodas yra panašus į every() metodą, tik jis patikrina, ar bent vienas elementas atitinka sąlygą. Ir šiuo atveju metodas some() grąžina true . Jei masyve nėra elementų, atitinkančių sąlygą, grąžinama false:

Variantų skaičiai = [ 1, -12, 8, -4, 25, 42 ]; funkcijos sąlyga(reikšmė, indeksas, masyvas) ( var rezultatas = false; if (reikšmė === 8) ( rezultatas = tiesa; ) grąžina rezultatą; ); var praėjo = skaičiai.kai(sąlyga); // tiesa

filtras()

Filtro() metodas, kaip kai kurie() ir every() , naudoja sąlyginę funkciją. Tačiau tuo pat metu jis grąžina masyvą tų elementų, kurie atitinka šią sąlygą:

Variantų skaičiai = [ 1, -12, 8, -4, 25, 42 ]; funkcijos sąlyga(reikšmė, indeksas, masyvas) ( var rezultatas = false; if (reikšmė > 0) ( rezultatas = tiesa; ) grąžina rezultatą; ); var filteredSkaičiai = skaičiai.filtras(sąlyga); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

Išvestis naršyklėje:

1 8 25 42

forEach () ir žemėlapis ()

Metodai forEach() ir map() kartoja elementus ir atlieka su jais tam tikras operacijas. Pavyzdžiui, norėdami apskaičiuoti skaičių kvadratus masyve, galite naudoti šį kodą:

var skaičiai = [ 1, 2, 3, 4, 5, 6]; for(var i = 0; i "); }

Tačiau naudodami forEach() metodą galite supaprastinti šią konstrukciją:

var skaičiai = [ 1, 2, 3, 4, 5, 6]; function square(reikšmė, indeksas, masyvas) ( var rezultatas = reikšmė * reikšmė; document.write("Skaičiaus kvadratas " + reikšmė + " yra " + rezultatas + "
"); ); skaičiai.Kiekvienam(kvadratas);

Metodas forEach() kaip parametrą paima tą pačią funkciją, kuriai, kartojant elementus, perduodamas dabartinis iteruojamas elementas ir su juo atliekamos operacijos.

Map() metodas yra panašus į forEach metodą, jis taip pat kaip parametras ima funkciją, kuri atlieka operacijas su iteruotais masyvo elementais, tačiau metodas map() grąžina naują masyvą su operacijų su masyvo elementais rezultatais. .

Pavyzdžiui, pritaikykime žemėlapio metodą masyvo skaičių kvadratams apskaičiuoti:

var skaičiai = [ 1, 2, 3, 4, 5, 6]; funkcija kvadratas(reikšmė, indeksas, masyvas) ( grąžinimo rezultatas = reikšmė * reikšmė; ); var squareArray = skaičiai.žemėlapis(kvadratas); document.write(squareArray);

Funkcija, perduodama map() metodui, gauna šiuo metu kartojamą elementą, atlieka su juo operacijas ir grąžina tam tikrą reikšmę. Tada ši reikšmė perduodama į gautą squareArray

Ir kaip supratote iš to straipsnio, kintamajame gali būti saugoma tik viena reikšmė. Kiek mes stengtumėmės kintamajame nerašysime daugiau nei vienos reikšmės.

Tarkime, mes deklaruojame kokį nors kintamąjį z ir priskiriame jam reikšmę 8. O jei kode kur nors žemiau nustatome kitokią reikšmę, tarkime, 3, tai senoji reikšmė išnyks ir vietoj jos bus rašoma nauja.

O tam, kad kintamajame būtų galima įrašyti daugiau nei vieną reikšmę, tokį duomenų tipą reikia naudoti kaip masyvą.

masyvas leidžia vienu metu įrašyti į kintamąjį neribotą skaičių bet kokio tipo reikšmių.

Anksčiau „JavaScript“ masyvas buvo deklaruojamas taip:

Var arr = naujas Masyvas(7, 8, "k", "v", 3.2, 4);

Laikai pasikeitė ir dabar masyvas deklaruojamas kitaip, labiau sutrumpintas. Elementai taip pat pateikiami atskirti kableliais, bet jau paprastuose laužtiniuose skliaustuose.

Var arr = [ 7, 8, "k", "v", 3.2, 4 ];

Dabar arr kintamasis yra vienmatis duomenų masyvas, skirtingi tipai.

Kiekvienas masyvo elementas turi savo indeksą. Atkreipkite dėmesį, kad šis indeksas prasideda nuo nulio. Jis nurodo elemento vietą masyve.

Masyvo struktūra atrodo taip:

Norint nurodyti kokį nors elementą iš masyvo, reikia parašyti masyvo pavadinimą, o laužtiniuose skliaustuose nurodyti elemento, kurio norime gauti, indeksą.

Pavyzdžiui, parodykime elementą, kurio indeksas yra 2, tai yra raidė "k".

Document.write("

Rodome elementą masyvo arr, kurio indeksas lygus 2: " + arr + "

); // k

O jei norime peržiūrėti visus masyvo elementus. Jei elementų yra nedaug, galite nurodyti kiekvieną atskirai, kaip pavyzdyje, tai yra, arr, arr, arr.

Bet jei masyve yra 100 elementų, ši parinktis nerodoma. Čia reikia naudoti.

Prieš pereidamas prie kartojimo per masyvą, noriu supažindinti jus su nuosavybe ilgio. Tai universali savybė, leidžianti rasti masyvo ilgį, tai yra bendras elementų skaičius masyve. Jis taip pat gali būti naudojamas norint sužinoti eilutės ilgį.

Kad būtų smagu, išsiaiškinkime, kiek ilgio turi masyvas.

Document.write("

Elementų skaičius masyve arr =" + arr.length + "

); // Rezultatas: 6

Dabar, kad visi elementai būtų rodomi vienu metu, kartokite per visą masyvą naudodami kilpą.

For(var i = 0; i< arr.length; i++){ document.write("

Masyvo elementas arr, su indeksu " + aš + " lygus: " + arr[i] + "

"); }

Atidarome šį puslapį naršyklėje ir matome tokį paveikslėlį:

Praktikos tikslais pabandykite pereiti per "arr" masyvą ir naudoti likusias while ir do-while kilpas.

Yra dar vienas paprastas ir trumpas surašymo variantas mažas masyvas. Tai slypi tame, kad kiekvieną masyvo elementą galima peržiūrėti naudojant įspėjimo metodą. Pirmiausia parašome paties masyvo pavadinimą arba galite iš karto nurodyti elementų sąrašą laužtiniuose skliaustuose. Tada rašome funkciją forEach ir kaip parametrą įrašome įspėjimo metodą be skliaustų.

Arr.forEach(alert);

Dabar, jei atidarysime puslapį naršyklėje, pamatysime kiekvieną masyvo elementą paeiliui.

Masyvo užpildymas kilpa

Pavyzdžiui, tam tikrame masyve surašysime daugybos lentelės rezultatus nuo 1 iki 10.

Pirmiausia turite deklaruoti tuščią masyvą, kurį užpildysime. Tada reikia deklaruoti kintamąjį ir nedelsiant jam priskirti reikšmę 0. Šis kintamasis bus naudojamas kaip deklaruoto masyvo indeksas. Ir kitas žingsnis yra užpildyti patį masyvą, naudojant tokią techniką kaip ciklas cikle.

//Pareikšti tuščią masyvą var new_arr = ; // Kintamasis kaip masyvo indeksas new_arr var k = 0; for(var i = 1; i

Jei atidarysime šį puslapį naršyklėje, pamatysime tokį rezultatą:

Iš pradžių kintamasis i lygus vienetui. Ir šis padauginamas iš visų kintamojo j reikšmių. Perėję antrąją kilpą 10 kartų, grįžtame prie pirmosios kilpos ir padidiname kintamąjį i vienu. Dabar aš lygus dviem. Vėl einame į antrąją kilpą ir padauginame 2 reikšmę iš visų kintamojo j reikšmių (nuo 1 iki 10). Rezultatas yra antroji eilutė: 2 4 6 8 ... 20. Ir tai vyksta tol, kol kintamasis i tampa lygus 11. Kai tik jis įgauna šią reikšmę, išeiname iš ciklo.

Apskaičiuokite visų masyvo elementų sumą

Turime masyvą new_arr, kuriame saugoma 100 skaičių (visa daugybos lentelė). Dabar apskaičiuokime visų šių elementų sumą.

//Sukurti kintamąjį sum var summ = 0; for(var i = 0; i< new_arr.length; i++){ summ += new_arr[i]; } document.write("

Masyvo new_arr elementų suma yra: " + summ + "

"); //Rezultatas 3025

Tai viskas, apie ką norėjau papasakoti šiame straipsnyje. Dabar tu žinai, kaip sukurti masyvą, kaip jį užpildyti ir kaip su juo dirbti.

Praktikoje masyvai yra gana paplitę, nes jie yra labai svarbūs programuojant, todėl turėtumėte gerai juos pažįsta.

Masyvai

masyvas yra tvarkingas vertybių rinkinys. Masyvo reikšmės vadinamos elementais, o kiekvienam elementui būdinga skaitinė padėtis masyve, kuri vadinama indeksu. „JavaScript“ masyvai nėra tipuojami: masyvo elementai gali būti bet kokio tipo, o skirtingi to paties masyvo elementai gali turėti skirtingus tipus. Masyvo elementai netgi gali būti objektai ar kiti masyvai, leidžiantys sukurti sudėtingas duomenų struktūras, pvz., objektų masyvus ir masyvų masyvus.

JavaScript masyvo indeksai yra pagrįsti nuliu ir naudojami 32 bitų sveikieji skaičiai – pirmasis masyvo elementas turi indeksą 0. Masyvai JavaScript yra dinamiški: jie gali augti ir mažėti pagal poreikį; nereikia deklaruoti fiksuotų masyvų dydžių, kai jie sukuriami, arba perskirstyti atminties, kai pasikeičia jų dydžiai.

Masyvai „JavaScript“ yra specializuota objektų forma, o masyvo indeksai reiškia šiek tiek daugiau nei tik ypatybių pavadinimus, kurie atsitiktinai yra sveikieji skaičiai.

Masyvų kūrimas

Lengviausias būdas sukurti masyvą yra naudojant literalą, kuris yra paprastas kableliais atskirtas masyvo elementų sąrašas laužtiniuose skliaustuose. Vertės masyvo literale nebūtinai turi būti konstantos – tai gali būti bet kokia išraiška, įskaitant objektinius literalius:

var tuščias = ; // Tuščias masyvas var numbers = ; // Masyvas su penkiais skaitiniais elementais var misc = [ 1.1, true, "a", ]; // 3 skirtingų tipų elementai + galinis kablelis var base = 1024; var lentelė = ; // Masyvas su kintamaisiais var arrObj = [, ]; // 2 masyvai viduje, kuriuose yra objektai

Masyvo pažodinė sintaksė leidžia pasirinktinai galinį kablelį, t.y. pažodinis [,] atitinka masyvą su dviem elementais, o ne trimis.

Kitas būdas sukurti masyvą yra iškviesti konstruktorių masyvas (). Galite iškviesti konstruktorių trimis skirtingais būdais:

Iškvieskite konstruktorių be argumentų:

Var arr = naujas Masyvas();

Tokiu atveju bus sukurtas tuščias masyvas, atitinkantis literalą.

Iškvieskite konstruktorių naudodami vieną skaitinį argumentą, nurodantį masyvo ilgį:

Var arr = naujas Masyvas(10);

Tokiu atveju bus sukurtas tuščias nurodyto ilgio masyvas. Šią Array() konstruktoriaus iškvietimo formą galima naudoti norint iš anksto paskirstyti atmintį masyvei, jei jo elementų skaičius yra žinomas iš anksto. Atminkite, kad tai masyve nesaugo jokių reikšmių.

Konstruktoriumi aiškiai nurodykite pirmųjų dviejų ar daugiau masyvo elementų arba vieno neskaitinio elemento reikšmes:

Var arr = new Masyvas(5, 4, 3, 2, 1, "testas");

Šiuo atveju konstruktoriaus argumentai tampa naujo masyvo elementų reikšmėmis. Naudoti masyvo literalus beveik visada lengviau nei naudoti tokį konstruktorių Array() kaip šis.

Masyvo elementų skaitymas ir rašymas

Masyvo elementai pasiekiami naudojant . Skliaustų kairėje turi būti masyvo nuoroda. Skliausteliuose turi būti savavališka išraiška, kuri grąžina neneigiamą sveikojo skaičiaus reikšmę. Ši sintaksė tinka tiek masyvo elemento reikšmei skaityti, tiek rašyti. Todėl galioja visi šie „JavaScript“ teiginiai:

// Sukurti masyvą su vienu elementu var arr = ["pasaulis"]; // Skaityti elementą 0 var value = arr; // Įrašykite reikšmę 1 elementui arr = 3,14; // Įrašykite 2 elemento reikšmę i = 2; arr[i] = 3; // Įrašykite 3 elemento reikšmę arr = "labas"; // Skaityti elementus 0 ir 2, įrašyti reikšmę į 3 elementą arr] = arr;

Leiskite jums priminti, kad masyvai yra specializuota objektų rūšis. Masyvo elementams pasiekti naudojami laužtiniai skliaustai veikia lygiai taip pat, kaip ir laužtiniai skliaustai, naudojami objekto savybėms pasiekti. „JavaScript“ interpretatorius paverčia skliausteliuose surašytus skaitinius indeksus į eilutes – 1 indeksas tampa eilute „1“ – ir tada eilutes naudoja kaip savybių pavadinimus.

Skaitinių indeksų konvertavimas į eilutes nėra nieko ypatingo: tą patį galima padaryti su įprastais objektais:

var obj = (); // Sukurti paprastą objektą obj = "vienas"; // Indeksuokite jį sveikaisiais skaičiais

Masyvų ypatumas yra tas, kad naudojant savybių pavadinimus, kurie yra neneigiami sveikieji skaičiai, masyvai automatiškai nustato ypatybės vertę ilgio. Pavyzdžiui, masyvas arr buvo sukurtas aukščiau su vienu elementu. Tada jis priskyrė reikšmes savo elementams indeksuose 1, 2 ir 3. Dėl šių operacijų masyvo ilgio savybės reikšmė pasikeitė į 4.

Turėtumėte aiškiai atskirti masyvo indeksus ir objektų ypatybių pavadinimus. Visi indeksai yra ypatybių pavadinimai, bet tik ypatybės, kurių pavadinimai vaizduojami sveikaisiais skaičiais, yra indeksai. Visi masyvai yra objektai, ir jūs galite pridėti prie jų savybių bet kokiais pavadinimais. Tačiau jei paliečiate ypatybes, kurios yra masyvo indeksai, masyvai reaguoja atnaujindami ilgio ypatybės vertę, jei reikia.

Atkreipkite dėmesį, kad kaip masyvo indeksus leidžiama naudoti neigiamus ir ne sveikuosius skaičius. Šiuo atveju skaičiai konvertuojami į eilutes, kurios naudojamos kaip savybių pavadinimai.

Masyvo elementų pridėjimas ir pašalinimas

Jau matėme, kad paprasčiausias būdas įtraukti elementus į masyvą yra priskirti reikšmes naujiems indeksams. Taip pat galite naudoti šį metodą, norėdami pridėti vieną ar daugiau elementų į masyvo pabaigą. stumti ():

Var arr = ; // Sukurti tuščią masyvą arr.push("zero"); // Pridėti vertę į pabaigą arr.push("one",2); // Pridėkite dar dvi reikšmes

Taip pat galite pridėti elementą prie masyvo pabaigos, priskirdami arr elemento reikšmę. Norėdami įterpti elementą masyvo pradžioje, galite naudoti šį metodą unshift (), kuris perkelia esamus masyvo elementus į aukštesnes indekso pozicijas.

Masyvo elementus galima ištrinti naudojant trynimo operatorių, kaip ir įprastas objekto savybes:

Var arr = ; ištrinti arr; 2 in arr; // false, masyvo indeksas 2 neapibrėžtas arr.length; // 3: trynimo operatorius nekeičia masyvo ilgio savybės

Elemento pašalinimas yra panašus (bet šiek tiek kitoks) kaip neapibrėžto elemento priskyrimas tam elementui. Atkreipkite dėmesį, kad masyvo elementui pritaikius trynimo operatorių nekeičia ilgio ypatybės reikšmės, taip pat nejudinami elementai su aukštesniais indeksais žemyn, kad būtų užpildyta tuštuma, kurią paliko ištrinamas elementas.

Taip pat galima pašalinti elementus masyvo pabaigoje tiesiog priskiriant naują reikšmę ilgio savybei. Masyvai turi metodą pop ()(priešingai push()), kuris sumažina masyvo ilgį 1 ir grąžina pašalinto elemento reikšmę. Taip pat yra metodas shift ()(priešingai nei unshift() metodui), kuris pašalina elementą masyvo pradžioje. Skirtingai nei trynimo operatorius, Shift() metodas perkelia visus elementus žemyn į padėtį žemiau jų dabartinių indeksų.

Galiausiai yra daugiafunkcis metodas sandūra (), kuri leidžia įterpti, pašalinti ir pakeisti masyvų elementus. Jis pakeičia ilgio ypatybės reikšmę ir prireikus perkelia masyvo elementus su mažesniais arba aukštesniais indeksais. Visus šiuos metodus aptarsime šiek tiek vėliau.

Daugiamačiai masyvai

„JavaScript“ nepalaiko „tikrųjų“ daugiamačių masyvų, tačiau malonu juos imituoti masyvų masyvais. Norint pasiekti duomenų elementą masyvo masyve, pakanka du kartus naudoti operatorių.

Pavyzdžiui, tarkime, kad kintamoji matrica yra skaičių masyvų masyvas. Kiekvienas matricos [x] elementas yra skaičių masyvas. Norėdami pasiekti konkretų skaičių masyve, galite naudoti matricos [x][y] išraišką. Toliau pateikiamas konkretus pavyzdys, kai dvimatis masyvas naudojamas kaip daugybos lentelė:

// Sukurti daugiamatį masyvą var table = new Array(10); // Lentelėje yra 10 eilučių for(var i = 0; i

Masyvo klasių metodai

ECMAScript 3 standartas apibrėžia daugybę patogumo funkcijų, skirtų darbui su masyvais kaip Array.prototype dalis, kurios yra prieinamos kaip bet kurio masyvo metodai. Šie metodai bus pateikti tolesniuose poskyriuose.

prisijungimo () metodas

Metodas Array.join() konvertuoja visus masyvo elementus į eilutes, jas sujungia ir grąžina gautą eilutę. Kaip pasirenkamą metodo argumentą galite perduoti eilutę, kuri bus naudojama elementams atskirti rezultatų eilutėje. Jei skyriklio eilutė nenurodyta, naudojamas kablelis. Pavyzdžiui, šis fragmentas sukelia eilutę „1,2,3“:

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

atvirkštinis () metodas

Metodas Array.reverse() pakeičia masyvo elementų tvarką ir grąžina pertvarkytą masyvą. Permutacija atliekama tiesiogiai pirminiame masyve, t.y. šis metodas nesukuria naujo masyvo su pertvarkytais elementais, o pertvarko juos jau esamame masyve. Pavyzdžiui, šis fragmentas, kuriame naudojami reverse() ir join() metodai, sukuria eilutę „3,2,1“:

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

Rūšiuoti() metodas

Metodas Array.sort() surūšiuoja pradinio masyvo elementus ir grąžina surūšiuotą masyvą. Jei metodas sort() iškviečiamas be argumentų, rūšiavimas atliekamas abėcėlės tvarka (jei reikia, elementai laikinai konvertuojami į eilutes palyginimui). Neapibrėžti elementai perkeliami į masyvo pabaigą.

Norėdami rūšiuoti ne pagal abėcėlę, galite perduoti palyginimo funkciją kaip argumentą rūšiavimo () metodui. Ši funkcija nustato, kuris iš dviejų argumentų turi būti pirmas rūšiuojamame sąraše. Jei pirmasis argumentas turi būti prieš antrąjį, palyginimo funkcija turi grąžinti neigiamą skaičių. Jei pirmasis argumentas turi sekti antrąjį surūšiuotame masyve, funkcija turi grąžinti skaičių, didesnį už nulį. Ir jei dvi reikšmės yra lygiavertės (t. y. jų tvarka nėra svarbi), palyginimo funkcija turėtų grąžinti 0:

Var arr = ; arr.sort(); // Abėcėlės tvarka: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Skaičių tvarka: 4, 33, 222, 1111 return a-b; // Grąžina reikšmę 0 // priklausomai nuo rūšiavimo tvarkos a ir b)); // Rūšiuoti atgal, nuo didžiausio iki mažiausio arr.sort(function(a,b) (return b-a));

Atkreipkite dėmesį, kaip patogu šiame fragmente naudoti neįvardytą funkciją. Palyginimo funkcija naudojama tik čia, todėl nereikia jai suteikti pavadinimo.

concate() metodas

Metodas Array.concat() sukuria ir grąžina naują masyvą, kuriame yra pradinio masyvo, kuriame buvo iškviestas concat() metodas, elementai ir bet kokių argumentų reikšmės, perduodamos concat() metodui. Jei kuris nors iš šių argumentų yra masyvas, jo elementai pridedami prie grąžinamo masyvo. Tačiau reikia pažymėti, kad nėra rekursinio masyvo transformavimo į vienmatį masyvą. Concat() metodas nekeičia pradinio masyvo. Žemiau pateikiami keli pavyzdžiai:

Var arr = ; arr.concat(4, 5); // Grąžinti arr.concat(); // Grąžina arr.concat(,) // Grąžina arr.concat(4, ]) // Grąžina ]

slice() metodas

Metodas Array.slice() grąžina nurodyto masyvo pjūvį arba pogrupį. Du metodo argumentai apibrėžia grąžinamo fragmento pradžią ir pabaigą. Grąžintame masyve yra elementas, kurio numeris nurodytas pirmame argumente, ir visi paskesni elementai iki (bet neįskaitant) elemento, kurio numeris nurodytas antrajame argumente.

Jei pateikiamas tik vienas argumentas, grąžintame masyve yra visi elementai nuo pradinės padėties iki masyvo pabaigos. Jei kuris nors iš argumentų yra neigiamas, jis nurodo elemento numerį, palyginti su masyvo pabaiga. Taigi argumentas -1 atitinka paskutinį masyvo elementą, o argumentas -3 – trečią masyvo elementą nuo galo. Štai keletas pavyzdžių:

Var arr = ; arr skiltis(0,3); // Grąžina arr.slice(3); // Grąžina arr.slice(1,-1); // Grąžina arr.slice(-3,-2); // Grįžti

splice() metodas

Metodas Array.splice() yra bendras metodas, kuris įterpia arba pašalina masyvo elementus. Skirtingai nuo slice() ir concat() metodų, splice() metodas modifikuoja pradinį masyvą, kuriame jis buvo iškviestas. Atminkite, kad splice () ir slice () metodai turi labai panašius pavadinimus, tačiau atlieka visiškai skirtingas operacijas.

Splice () metodas gali pašalinti elementus iš masyvo, įterpti naujus elementus arba atlikti abu tuo pačiu metu. Masyvo elementai perkeliami, jei reikia, kad susidarytų gretima seka po įterpimo arba ištrynimo.

Pirmasis splice() metodo argumentas nurodo vietą masyve, iš kurios bus atliktas įterpimas ir (arba) trynimas. Antrasis argumentas nurodo elementų, kuriuos reikia pašalinti (iškirpti) iš masyvo, skaičių. Jei antrasis argumentas yra praleistas, visi masyvo elementai nuo nurodyto masyvo iki masyvo pabaigos pašalinami. Splice() metodas grąžina pašalintų elementų masyvą arba (jei elementų nepašalinta) tuščią masyvą.

Pirmieji du splice() metodo argumentai nustato masyvo elementus, kuriuos reikia pašalinti. Po šių argumentų gali sekti bet koks pasirenkamų argumentų skaičius, nurodantis elementus, kurie turi būti įterpti į masyvą, pradedant nuo pirmame argumente nurodytos pozicijos.

Var arr = ; arr.splice(4); // Grąžina , arr = arr.splice(1,2); // Grąžina , arr = arr.splice(1,1); // Grąžina ; arr = arr = ; arr.splice(2,0"a","b"); // Grąžina ; arr=

push() ir pop() metodai

Push() ir pop() metodai leidžia masyvus traktuoti kaip krūvas. Push() metodas prideda vieną ar daugiau naujų elementų į masyvo pabaigą ir grąžina naują ilgį. Pop() metodas atlieka atvirkštinę operaciją – pašalina paskutinį masyvo elementą, sumažina masyvo ilgį ir grąžina pašalintą reikšmę. Atminkite, kad abu šie metodai modifikuoja pradinį masyvą, o ne sukuria modifikuotą jo kopiją.

unshift() ir shift() metodai

Metodai unshift() ir shift() veikia panašiai kaip push() ir pop(), išskyrus tai, kad jie įterpia ir pašalina elementus masyvo pradžioje, o ne pabaigoje. Metodas unshift() perkelia esamus elementus į aukštesnius indeksus, kad atlaisvintų vietos, prideda elementą ar elementus į masyvo pradžią ir grąžina naują masyvo ilgį. Shift() metodas pašalina ir grąžina pirmąjį masyvo elementą, perkeldamas visus paskesnius elementus viena pozicija žemyn, kad užpildytų masyvo pradžioje laisvą vietą.

Šioje pamokoje mes susipažinsime su masyvais, išmoksime juos kurti, atlikti operacijas su jų elementais, taip pat apsvarstysime pagrindinius metodus ir savybes, kurias galima naudoti dirbant su jais.

Kas yra „JavaScript“ masyvas?

Masyvas yra užsakytas vertybių rinkimas. Šios kolekcijos vertės vadinamos elementais. Kiekvienas masyvo elementas turi savo serijos numerį (numerį), kuris vadinamas indeksu. Indeksai numeruojami nuo 0.

Toliau pateiktame paveikslėlyje parodytas skaitmeninis masyvas su 5 elementais. Šio masyvo elementuose yra šie duomenys: 123 (indeksas 0), 7 (indeksas 1), 50 (indeksas 2), -9 (indeksas 3), 24 (indeksas 4).

Masyvo sukūrimas (deklaravimas).

Masyvų kūrimas „JavaScript“ paprastai atliekamas naudojant masyvas pažodinis.

Masyvo literalas yra laužtiniai skliaustai, kuriuose yra kableliais atskirtų elementų sąrašas.

Pavyzdžiui:

var tuščias = ; // tuščias masyvas var numbers = ; // skaitmeninis masyvas var arr = ; // masyvas, kuriame yra įvairių tipų duomenų

„JavaScript“ masyvo reikšmės neturi būti to paties tipo. Tie. Viename masyve gali būti skirtingų duomenų tipų reikšmės.

Masyvo elementas pasiekiamas naudojant jo indeksą. Ši operacija taip pat vadinama indeksavimo operacija.

Pavyzdžiui:

// sukurti 3 elementų masyvą var smartphoneColors = ["Juoda", "Balta", "Pilka"]; // naršyklės konsolėje rodyti išmaniojo telefono masyvo elementų reikšmes Colors su indeksais 0 ir 2 console.log("SmartphoneColors masyvo elemento su indeksu 0 reikšmė: " + smartfonColors); // "SmartphoneColors masyvo elemento reikšmė indekse 0: Black" console.log("SmartphoneColors masyvo elemento vertė 2 indekse: " + smartfonColors); // "SmartphoneColors masyvo elemento reikšmė indekse 0: Grey" // pakeisti smartfon Colors masyvo elemento reikšmę indekse 1 į "Red" smartfonColors = "Red"; // ["Black", "Red", "Grey"] // nustatykite smartfonColors masyvo elementą 3 indekse į "Blue" smartfonColors = "Blue"; // ["Juoda", "Raudona", "Pilka", "Mėlyna"]

Kaip masyvo elementų reikšmes galite naudoti ne tik statines reikšmes, bet ir išraiškas:

var ilgisA = 7, plotisA = 5; var taškas = ;

Objektai gali būti naudojami kaip masyvo elementų reikšmės.

Variklio taškai = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0)]; // masyvas, susidedantis iš 3 objektų

Kitas būdas sukurti masyvą susideda iš masyvo konstruktoriaus funkcijos iškvietimo.

Konstruktoriaus funkcijos iškvietimas be argumentų naudojamas tuščiam masyvui sukurti.

Var tuščias = naujas Masyvas(); // tuščias masyvas

Šis masyvo kūrimo būdas prilygsta pažodžiui .

Jei nurodysite skaičių kaip konstruktoriaus funkcijos argumentą, tada bus sukurtas masyvas, kurį sudarys nurodytas elementų skaičius. Be to, visų šių elementų vertė bus neapibrėžta.

Var arr = naujas Masyvas(5); // 5 elementų masyvas (elementų reikšmės neapibrėžtos)

Jei konstruktoriaus funkcijai skliausteliuose perduodamos kelios reikšmės arba viena neskaitinė reikšmė, iš jai perduotų argumentų bus sukurtas masyvas.

Skirtingai nuo daugelio kitų programavimo kalbų, JavaScript masyvai automatiškai keičia savo dydį, t.y. iš pradžių jie yra dinamiški. Tokiems masyvams nereikia duoti jokių matmenų. Kitas skiriamasis JavaScript masyvų bruožas yra tas, kad skirtinguose to paties masyvo elementuose gali būti skirtingų tipų duomenų.

ilgio savybė (masyvo ilgis)

Masyvo ilgio (elementų skaičiaus) nustatymas atliekamas naudojant ilgio savybę.

//sukurkite masyvą įtraukdami elementų reikšmes į funkciją Array var volumeHDDs = new Array ("500Gb","1Tb","2Tb"); //priskirkime volumeHDDs masyvo ilgį kintamajam ilgisArray var lengthArray = volumeHDDs.length;

Kaip gauti pirmąjį masyvo elementą

Pirmojo masyvo elemento reikšmė gaunama šio masyvo laužtiniuose skliaustuose nurodant skaičių 0:

//sukurti masyvą, susidedantį iš 3 elementų var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //gaunant pirmojo masyvo elemento reikšmę var firstValue = volumeHDDs;

Kaip gauti paskutinį masyvo elementą

Paskutinio masyvo elemento reikšmė gaunama šio masyvo laužtiniuose skliaustuose nurodant išraišką masyvo_pavadinimas.ilgis-1:

//sukurti masyvą, susidedantį iš 3 elementų var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //gauti paskutinio masyvo elemento reikšmę var lastValue = volumeHDDs;

Kartojimas per masyvą

Masyvo elementų kartojimas atliekamas naudojant for kilpą.

Pavyzdžiui, pakartokime visus masyvo elementus ir parodykime jų reikšmes naršyklės konsolėje (F12):

//masyvo pavadinimo kūrimasStudentai, susidedantys iš 4 elementų var nameStudents = new Array("Petras","Vasya","Kolya","Maxim"); // kartoti masyvo elementus nuo 0 iki masyvo ilgio-1 (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

Koks yra trynimo operatoriaus tikslas

Ištrynimo operatorius nenaudojamas elementui pašalinti iš masyvo, o tam, kad tam tikram masyvo elementui priskirtų reikšmę neapibrėžta.

Var namePlanets = new Array("Venera","Merkurijus","Žemė","Marsas"); ištrinti pavadinimąPlanetos; už (var i = 0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Funkcijos, skirtos darbui su masyvais (masyvo objekto metodai)

Objekte Array yra šie darbo su masyvais metodai (funkcijos):

pamaina
perjungti
gabalas
sandūrą
padalintas
atvirkščiai

stūmimo metodas (elemento įtraukimas į masyvo pabaigą)

Stūmimo metodas skirtas elementui pridėti prie masyvo pabaigos. Šio elemento reikšmė nurodoma kaip šio metodo parametras. Dėl to stūmimo metodas grąžina masyvo elementų skaičių, atsižvelgiant į pridėtą.

Var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas"]; pavadinimasPlanetos.push("Jupiteris"); // 5 console.log(pavadinimasPlanetos); // ["Venera", "Merkurijus", "Žemė", "Marsas", "Jupiteris"]

pop metodas (paskutinio elemento pašalinimas iš masyvo)

Pop metodas yra skirtas pašalinti paskutinį elementą iš masyvo. Šis metodas neturi parametrų. Dėl to jis grąžina paskutinio (pašalinto) masyvo elemento reikšmę.

Var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas"]; pavadinimasPlanetos.pop(); // "Mars" konsolė.log(pavadinimasPlanetos); // ["Venera", "Merkurijus", "Žemė"]

Shift metodas (pirmojo elemento pašalinimas iš masyvo)

Shift metodas skirtas pašalinti pirmąjį elementą iš masyvo, t.y. elementas, kurio indeksas 0. Visi kiti masyvo elementai perkeliami į pradžią, t.y. kiekvienam iš jų indeksas sumažėja 1. Šis metodas grąžina pašalinto elemento reikšmę.

Var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas"]; pavadinimasPlanetos.shift(); // "Veneros" konsolė.log(pavadinimasPlanetos); // ["Merkurijus", "Žemė", "Marsas"]

unshift metodas (elemento įtraukimas į masyvo pradžią)

Unshift metodas skirtas įtraukti elementą į masyvo pradžią (prieš kitus elementus). Šio elemento reikšmė nurodoma kaip šio metodo parametras. Dėl to šis metodas grąžina masyvo elementų skaičių, atsižvelgiant į pridėtą.

Var namePlanets = ["Merkurijus", "Žemė", "Marsas", "Jupiteris"]; pavadinimasPlanetos.unshift("Venera"); // 5 console.log(pavadinimasPlanetos); // ["Venera", "Merkurijus", "Žemė", "Marsas", "Jupiteris"]

Pjūvio metodas (masyvo dalies kopijavimas)

Pjūvio metodas yra skirtas masyvo daliai kopijuoti. Tuo pačiu metu jis nepakeičia pradinio masyvo, o grąžina naują masyvą, sudarytą iš pasirinktų elementų.

Pjaustymo metodas turi 2 parametrus:

1 parametras (privalomas) – naudojamas nurodyti elemento indeksą, nuo kurio pradėti kopijuoti elementus;
2-as parametras (neprivalomas) - skirtas nurodyti elemento, į kurį reikia kopijuoti, indeksą (jis neįtrauktas į naują masyvą). Jei jis nenurodytas, elementai bus nukopijuoti į nurodyto masyvo pabaigą.

var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas", "Jupiteris"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Žemė", "Marsas"]

sujungimo metodas (masyvo turinio keitimas)

Sujungimo metodas yra skirtas pakeisti masyvo turinį. Jis gali būti naudojamas tiek įtraukiant elementus į masyvą, tiek juos pašalinant.

Sujungimo metodo sintaksė yra tokia:

Masyvas.splice(startIndex, deleteCount [, element1[, element2[, ...]]]); /* startIndex (būtina) – pradinis elemento indeksas, nuo kurio pradedama keisti masyvą. Jei kaip startIndex nurodysite didesnį už masyvo ilgį skaičių, tada pradžios indeksas bus nustatytas į masyvo pabaigą. Jei kaip startIndex nurodysite neigiamą skaičių, pradinis elementas bus skaičiuojamas nuo pabaigos. deleteCount (būtina) – skaičius, nurodantis, kiek elementų reikia pašalinti iš masyvo. Jei iš masyvo nereikia pašalinti jokių elementų, tada deleteCount turi būti nustatytas į 0. Po to turi būti nurodytas bent vienas naujas elementas, kuris bus įtrauktas į masyvą. Jei nurodysite skaičių kaip deleteCount, kuris viršys likusių masyvo elementų skaičių, pradedant nuo startIndex, tokiu atveju jie vis tiek bus ištrinti (t. y. visi elementai iki masyvo pabaigos, pradedant nuo pradžios indekso) element1, element2, .. (neprivaloma) – elementai, kuriuos reikia įtraukti į masyvą. */

Sujungimo metodo naudojimo pavyzdžiai.

Naudojamas sujungimo metodas, kad pašalintų dalį elementų iš masyvo.

Var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas"]; pavadinimasPlanetos.sujungimas(2, 2); //["Žemė", "Marsas"] console.log(pavadinimasPlanetos); // ["Venera", "Merkurijus"]

Naudojant sujungimo metodą, norint pašalinti elementą iš masyvo ir pridėti prie jo naujų.

Var namePlanets = ["Venera", "Merkurijus", "Žemė", "Marsas"]; namePlanets.splice(1, 1, "Uranas", "Neptūnas", "Saturnas"); // ["Merkurijus"] console.log(pavadinimasPlanetos); // ["Venera", "Uranas", "Neptūnas", "Saturnas", "Žemė", "Marsas"]

Sujungimo metodo naudojimas tik naujų elementų įtraukimui į masyvą.

Var namePlanets = ["Jupiteris", "Saturnas", "Uranas"]; namePlanets.splice(0, 0, "Venera", "Merkurijus", "Žemė", "Marsas"); // console.log(pavadinimasPlanetos); // ["Venera", "Merkurijus", "Žemė", "Marsas", "Jupiteris", "Saturnas", "Uranas"]

prisijungimo metodas (konvertuoti masyvą į eilutę)

Sujungimo metodas skirtas sujungti visus masyvo elementus į eilutę.

Sujungimo metodo sintaksė yra tokia:

Masyvas.join(); /* separatorius (pasirinktinai) – skyriklis, naudojamas kaip jungiamoji eilutė tarp kiekvieno masyvo elemento. Jei šis parametras nenurodytas, "," bus naudojama kaip jungiamoji eilutė. Jei kaip parametrą nurodysite tuščią eilutę, masyvo elementai grąžintoje eilutėje nebus niekuo atskirti */

Var uogos = ["Vynuogės", "Vynuogės", "Serbentas", "Erškėtuogė"]; var berriesStr1 = uogos.join(); // "Vynuogės,Vynuogės,Serbentai, Erškėtuogės" var berriesStr2 = uogos.join(""); // "VynuogėsVynuogėsSerbentas Erškėtuogės" var berriesStr3 = uogos.join(", "); // "Vynuogės, Vynuogės, Serbentai, Erškėtuogės" var berriesStr4 = berries.join(" + "); // "Vynuogės + vynuogės + serbentai + erškėtuogės"

Jei skyriklis nėra eilutė, jis bus konvertuojamas į eilutę.

Var uogos = ["Vynuogės", "Vynuogės", "Serbentas", "Erškėtuogė"]; var berriesStr1 = uogos.join(false); // "GrapesfalseGrapesfalseCurrantfalseRoosehip" var berriesStr2 = berries.join(4/2); // "Grape2Grape2Currant2Rosehip" Masyvo elementai, kurių reikšmė yra nulis arba neapibrėžta, bus perduota į tuščią eilutę. var arr = ; vararrStr = arr.join(", "); // "0, 5, -4"

Konvertuoti eilutę į masyvą – padalinti

Padalijimo metodas skirtas konvertuoti eilutę į masyvą. Šis metodas turi vieną parametrą, kuriam galite nurodyti eilutę, pagal kurią ši eilutė bus padalinta į eilučių masyvą.

Var strElementComputers = "Sistemos blokas, monitorius, klaviatūra, pelė, garsiakalbiai, spausdintuvas"; var elementComputers = strElementComputers.split(", "); console.log("Elementų skaičius masyve: " + elementComputers.length); už (var i = 0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Masyvo elementų pertvarkymas atvirkštine tvarka – atvirkščiai

Atvirkštinis metodas skirtas masyvo elementų pertvarkymui atvirkštine tvarka.

Var namePlanets = new Array("Venera","Merkurijus","Žemė","Marsas"); pavadinimasPlanetos.atvirkščiai(); console.log("Elementų skaičius masyve: " + namePlanets.length); už (var i = 0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Rūšiuoti masyvo elementus – rūšiuoti

Rūšiavimo metodas skirtas masyvo elementams rūšiuoti. Pagal numatytuosius nustatymus šis metodas rūšiuoja masyvą kaip eilutes.

Var namePlanets = new Array("Venera","Merkurijus","Žemė","Marsas"); pavadinimasPlanetos.rūšiuoti(); console.log("Elementų skaičius masyve: " + namePlanets.length); už (var i = 0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }