Šajā nodarbībā iepazīsimies ar masīviem, uzzināsim, kā tos izveidot, veiksim darbības ar to elementiem, kā arī apskatīsim pamatmetodes un pieejamās īpašības, strādājot ar tiem.

Kas ir masīvs JavaScript?

Masīvs ir pasūtīta vērtību kolekcija. Šajā kolekcijā esošās vērtības sauc par elementiem. Katram masīva elementam ir savs sērijas numurs (numurs), ko sauc par indeksu. Indeksi ir numurēti, sākot no 0.

Nākamajā attēlā parādīts ciparu masīvs, kas sastāv no 5 elementiem. Šī masīva elementi satur šādus datus: 123 (indekss 0), 7 (indekss 1), 50 (indekss 2), -9 (indekss 3), 24 (indekss 4).

Masīva izveide (deklarēšana).

Masīvu izveide JavaScript parasti tiek veikta, izmantojot masīvs burtisks.

Masīva literāls sastāv no kvadrātiekavām, kas satur ar komatu atdalītu elementu sarakstu.

Piemēram:

Var tukšs = ; // tukšs masīvs var numuri = ; // ciparu masīvs var arr = ; // masīvs, kas satur dažādus datu tipus

JavaScript masīva vērtībām nav jābūt tāda paša veida. Tie. Viens masīvs var saturēt dažādu datu tipu vērtības.

Konkrētam masīva elementam var piekļūt, izmantojot tā indeksu. Šo darbību sauc arī par indeksēšanas darbību.

Piemēram:

// izveidot masīvu, kas sastāv no 3 elementiem var smartphoneColors = ["Black", "White", "Grey"]; // parādīt pārlūkprogrammas konsolē viedtālruņa Colors masīva elementu vērtības ar indeksiem 0 un 2 console.log("Viedtālruņa Colors masīva elementa vērtība ar indeksu 0: " + viedtālrunisColors); // "The value of viedtālrunisColors masīva elementa ar indeksu 0: Black" console.log("The value of viedtālrunisColors masīva elementa ar indeksu 2: " + viedtālrunisColors); // "The value of smartphoneColors masīva elementa ar indeksu 0: Gray" // mainīt viedtālruņa Colors masīva elementa ar indeksu 1 vērtību uz "Red" smartphoneColors = "Red"; // ["Black", "Red", "Grey"] // iestatiet viedtālruņa Colors masīva elementam ar indeksu 3 vērtību "Blue" smartphoneColors = "Blue"; // ["Melns", "Sarkans", "Pelēks", "Zils"]

Kā masīva elementu vērtības varat izmantot ne tikai statiskas vērtības, bet arī izteiksmes:

Var garumsA = 7, platums A = 5; var punkts = ;

Objektus var izmantot kā masīva elementu vērtības.

Var punkti = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // masīvs, kas sastāv no 3 objektiem

Vēl viens veids, kā izveidot masīvu sastāv no masīva konstruktora funkcijas izsaukšanas.

Lai izveidotu tukšu masīvu, tiek izmantots konstruktora funkcijas izsaukums bez argumentiem.

Var tukšs = jauns Array(); // tukšs masīvs

Šī masīva izveides metode ir līdzvērtīga literālam.

Ja konstruktora funkcijai norādāt skaitli kā argumentu, tas izveidos masīvu, kas sastāvēs no norādītā elementu skaita. Turklāt visu šo elementu vērtība būs nenoteikta.

Var arr = jauns Masīvs(5); // masīvs, kas sastāv no 5 elementiem (elementu vērtības nav definētas)

Ja konstruktora funkcijai iekavās nododat vairākas vērtības vai vienu vērtību, kas nav skaitliska, tā izveidos masīvu no tai nodotajiem argumentiem.

Atšķirībā no daudzām citām programmēšanas valodām, JavaScript masīvi automātiski maina savu izmēru, t.i. tie pēc būtības ir dinamiski. Šādiem masīviem nav jāpiešķir nekādi izmēri. Vēl viena atšķirīga JavaScript masīvu iezīme ir tā, ka viena un tā paša masīva dažādi elementi var saturēt dažāda veida datus.

garuma rekvizīts (masīva garums)

Masīva garuma (elementu skaita) noteikšana tiek veikta, izmantojot garuma īpašību.

//izveidojiet masīvu, uzskaitot elementu vērtības funkcijā Array var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //piešķirt volumeHDDs masīva garumam mainīgo lengthArray var lengthArray = volumeHDDs.length;

Kā iegūt pirmo masīva elementu

Masīva pirmā elementa vērtības iegūšana tiek veikta, šī masīva kvadrātiekavās norādot skaitli 0:

//masīva izveide, kas sastāv no 3 elementiem var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //masīva pirmā elementa vērtības iegūšana var firstValue = volumeHDDs;

Kā iegūt pēdējo masīva elementu

Masīva pēdējā elementa vērtību iegūst, šī masīva kvadrātiekavās norādot izteiksmi masīva_nosaukums.length-1:

//masīva izveide, kas sastāv no 3 elementiem var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //masīva pēdējā elementa vērtības iegūšana var lastValue = volumeHDDs;

Atkārtošana masīvā

Masīva elementu atkārtošana tiek veikta, izmantojot for cilpu.

Piemēram, atkārtosim visus masīva elementus un parādīsim to vērtības pārlūkprogrammas konsolē (F12):

//masīva nosaukuma izveideStudents, kas sastāv no 4 elementiem var nameStudents = new Array("Petya","Vasya","Kolya","Maxim"); //atkārtot masīva elementus no 0 līdz masīva garumam-1 (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

Kāds ir dzēšanas operatora mērķis?

Dzēšanas operators netiek izmantots, lai noņemtu elementu no masīva, bet lai piešķirtu noteiktam masīva elementam nenoteiktu vērtību.

Var nosaukumsPlanētas = new Array("Venēra","Merkurs","Zeme","Marss"); dzēst nosaukumuPlanētas; for (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Funkcijas darbam ar masīviem (masīva objektu metodes)

Masīva objekts satur šādas metodes (funkcijas) darbam ar masīviem:

• maiņa
• pārslēgt
• šķēle
• salaidums
• sadalīt
• otrādi

Push metode (elementa pievienošana masīva beigām)

Push metode ir paredzēta, lai pievienotu elementu masīva beigām. Šī elementa vērtība ir norādīta kā šīs metodes parametrs. Rezultātā push metode atgriež masīva elementu skaitu, ņemot vērā pievienoto.

Var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss"]; namePlanets.push("Jupiters"); // 5 console.log(namePlanets); // ["Venēra", "Dzīvsudrabs", "Zeme", "Marss", "Jupiters"]

pop metode (pēdējā elementa noņemšana no masīva)

Pop metode ir paredzēta, lai noņemtu pēdējo elementu no masīva. Šai metodei nav parametru. Rezultātā tas atgriež masīva pēdējā (noņemtā) elementa vērtību.

Var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss"]; nosaukumsPlanētas.pop(); // "Mars" konsole.log(namePlanets); // ["Venēra", "Dzīvsudrabs", "Zeme"]

Shift metode (pirmā elementa noņemšana no masīva)

Shift metode ir paredzēta, lai noņemtu pirmo elementu no masīva, t.i. elements ar indeksu 0. Visi pārējie masīva elementi tiek nobīdīti uz sākumu, t.i. katram no tiem indekss tiek samazināts par 1. Šī metode rezultātā atgriež noņemtā elementa vērtību.

Var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss"]; nosaukumsPlanetas.shift(); // "Venēra" konsole.log(nosaukumsPlanētas); // ["Dzīvsudrabs", "Zeme", "Marss"]

unshift metode (elementa pievienošana masīva sākumam)

Unshift metode ir paredzēta, lai pievienotu elementu masīva sākumam (pirms citiem elementiem). Šī elementa vērtība ir norādīta kā šīs metodes parametrs. Rezultātā šī metode atgriež masīva elementu skaitu, ņemot vērā pievienoto.

Var namePlanets = ["Dzīvsudrabs", "Zeme", "Marss", "Jupiters"]; nosaukumsPlanētas.unshift("Venēra"); // 5 console.log(namePlanets); // ["Venēra", "Dzīvsudrabs", "Zeme", "Marss", "Jupiters"]

šķēluma metode (masīva sadaļas kopēšana)

Šķēles metode ir paredzēta masīva sadaļas kopēšanai. Tomēr tas nemaina sākotnējo masīvu, bet atgriež kā rezultātā jaunu masīvu, kas sastāv no atlasītajiem elementiem.

Šķēles metodei ir 2 parametri:

• 1 parametrs (obligāts) - paredzēts, lai norādītu elementa indeksu, no kura sākt kopēt elementus;
• Parametrs 2 (pēc izvēles) - ir paredzēts, lai norādītu elementa indeksu, uz kuru ir nepieciešams kopēt (šajā gadījumā tas nav iekļauts jaunajā masīvā). Ja jūs to nenorādīsit, tiks kopēti elementi līdz norādītā masīva beigām.

var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss", "Jupiters"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Zeme", "Marss"]

Savienošanas metode (masīva satura maiņa)

Savienojuma metode ir paredzēta, lai mainītu masīva saturu. To var izmantot gan elementu pievienošanai masīvam, gan to noņemšanai.

Savienojuma metodes sintakse ir šāda:

Array.splice(startIndex, deleteCount [, elements1[, element2[, ...]]]); /* startIndex (obligāts) - elementa sākuma indekss, no kura jāsāk masīva maiņa. Ja kā startIndex norādāt skaitli, kas ir lielāks par masīva garumu, sākuma indekss tiks iestatīts uz masīva beigām. Ja kā startIndex norādāt negatīvu skaitli, sākuma elements tiks skaitīts no beigām. deleteCount (obligāti) - skaitlis, kas norāda, cik elementu ir jāizdzēš no masīva. Ja elementi no masīva nav jādzēš, tad deleteCount ir jāiestata uz 0. Pēc tam jānorāda vismaz viens jauns elements, kas jāpievieno masīvam. Ja kā deleteCount norādāt skaitli, kas pārsniegs atlikušo elementu skaitu masīvā, sākot no startIndex, tad šajā gadījumā tie joprojām tiks dzēsti (t.i., visi elementi līdz masīva beigām, sākot no sākuma indeksa) elements1, elements2, .. (pēc izvēles) - elementi, kas jāpievieno masīvam. */

Savienojuma metodes izmantošanas piemēri.

Izmantojot savienojuma metodi, lai noņemtu dažus elementus no masīva.

Var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss"]; nosaukumsPlanētas.savienojums(2, 2); //["Zeme", "Marss"] console.log(namePlanets); // ["Venēra", "Merkurs"]

Izmantojot savienojuma metodi, lai noņemtu elementu no masīva un pievienotu tam jaunus.

Var namePlanets = ["Venēra", "Merkurs", "Zeme", "Marss"]; namePlanets.splice(1, 1, "Uranus", "Neptūns", "Saturn"); // ["Mercury"] console.log(namePlanets); // ["Venēra", "Urāns", "Neptūns", "Saturns", "Zeme", "Marss"]

Savienojuma metodes izmantošana tikai, lai masīvam pievienotu jaunus elementus.

Var namePlanets = ["Jupiters", "Saturns", "Urāns"]; namePlanets.splice(0, 0, "Venēra", "Dzīvsudrabs", "Zeme", "Marss"); // konsole.log(nosaukumsPlanetas); // ["Venēra", "Dzīvsudrabs", "Zeme", "Marss", "Jupiters", "Saturns", "Urāns"]

pievienošanās metode (masīva pārveidošana par virkni)

Savienojuma metode ir paredzēta, lai visus masīva elementus apvienotu virknē.

Pievienošanās metodes sintakse:

Masīvs.join(); /* separators (pēc izvēles) - atdalītājs, kas tiek izmantots kā savienojošā virkne starp katru masīva elementu. Ja šis parametrs nav norādīts, kā savienojošā virkne tiks izmantota ",". Ja kā parametru norādāt tukšu virkni, masīva elementi atgrieztajā virknē netiks atdalīti ar neko */

Var ogas = ["Vīnogas", "Vīnogas", "Jogogas", "Mežrozīšu gurns"]; var berriesStr1 = berries.join(); // "Vīnogas, Vīnogas, jāņogas, rožu gurni" var berriesStr2 = berries.join(""); // "VīnogasVīnogasMežogas" var berriesStr3 = berries.join(", "); // "Vīnogas, Vīnogas, jāņogas, mežrozīšu augļi" var berriesStr4 = berries.join(" + "); // "Vīnogas + vīnogas + jāņogas + rožu gurni"

Ja kā atdalītāju izmantojat nevirkni, tā tiks pārveidota par virkni.

Var ogas = ["Vīnogas", "Vīnogas", "Jogogas", "Mežrozīšu gurns"]; var berriesStr1 = berries.join(false); // "GrapesfalseGrapesfalseCurrantfalseRosehip" var berriesStr2 = berries.join(4/2); // "Grapes2Grapes2Currant2Rose Hip" Masīva elementi, kuru vērtība ir nulle vai nav definēta, tiks nodoti tukšajā virknē. var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"

Virknes pārvēršana masīvā - sadalīšana

Sadalīšanas metode ir paredzēta, lai pārvērstu virkni masīvā. Šai metodei ir viens parametrs, kurā var norādīt virkni, uz kuras pamata šī virkne tiks sadalīta virkņu masīvā.

Var strElementComputers = "Sistēmas bloks, monitors, tastatūra, pele, skaļruņi, printeris"; var elementDatori = strElementDatori.split(", "); console.log("Elementu skaits masīvā: " + elementComputers.length); for (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Masīva elementu pārkārtošana apgrieztā secībā - apgrieztā secībā

Apgrieztā metode ir paredzēta masīva elementu pārkārtošanai apgrieztā secībā.

Var nosaukumsPlanētas = new Array("Venēra","Merkurs","Zeme","Marss"); nosaukumsPlanētas.reverse(); console.log("Elementu skaits masīvā: " + namePlanets.length); for (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Masīva elementu šķirošana - kārtot

Kārtošanas metode tiek izmantota masīva elementu kārtošanai. Pēc noklusējuma šī metode kārto masīvu kā virknes.

Var nosaukumsPlanētas = new Array("Venēra","Merkurs","Zeme","Marss"); nosaukumsPlanētas.kārtot(); console.log("Elementu skaits masīvā: " + namePlanets.length); for (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

21.06.2017 plkst.12:17

Lai aprēķinātu objektu masīva lielumu JavaScript, izmantojiet masīva garuma rekvizītu.

Var arr = ["pirmais", "otrais"]; konsole.log(arr.length); // 2

Javascript masīviem var nebūt indeksu. Piemēram

Var arr = ; arr = "pirmais"; arr = "otrais";

Garuma īpašība atgriež maksimālo masīva indeksu + 1. t.i. dotajā piemērā garums = 5.

Elementu skaita aprēķināšana masīvā JavaScript

Masīvs.prototips.skaits = funkcija())( var rezultāts = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }

Lietošanas piemērs

Var arr = ; arr = "pirmais"; arr = "otrais"; console.log(arr.count()); //2

Varat arī piešķirt garuma rekvizīta vērtību. Tas ļauj samazināt esošā masīva garumu.

Var arr = ["pirmais", "otrais", "trešais"]; arr.garums = 2; konsole.log(arr); // ["pirmā sekunde"]

Masīva lieluma baitos aprēķināšana javascript

Masīvi ir regulāri objekti, tāpēc masīva lieluma aprēķināšana baitos neatšķiras no jebkura cita objekta lieluma aprēķināšanas. Diemžēl javascript nenodrošina API lieluma aprēķināšanai, tāpēc jums tas būs jāaprēķina pašam. Tas tiek darīts šādi: mēs izejam cauri visām objekta īpašībām; ja īpašība ir primitīva tipa, mēs pievienojam šāda veida instances izmēru kopējam rezultātam; ja īpašumā ir objekts, mēs rekursīvi aprēķinam tā izmērs.

Funkcijas izmērsOf(obj) ( var baiti = 0; if(obj !== null && obj !== undefined) ( switch(typeof obj) ( case "number": baiti += 8; break; case "string": baiti += obj.length * 2; pārtraukums; reģistrs "būla": baiti += 4; pārtraukums; reģistrs "objekts": for(var atslēga obj) ( baiti += sizeOf(obj); ) pārtraukums; ) ) atgriež baitus ; );

Metode nav precīza un tai ir daudz problēmu – piemēram, pastāv iespēja iedziļināties nebeidzamā cilpā.

Pēdējā atjaunināšana: 26.03.2018

Masīva objekts attēlo masīvu un nodrošina vairākas īpašības un metodes, ar kurām mēs varam manipulēt ar masīvu.

Masīva inicializācija

Varat izveidot tukšu masīvu, izmantojot kvadrātiekavas vai masīva konstruktoru:

Var lietotāji = jauns Array(); var cilvēki = ; konsole.log(lietotāji); // Masīva konsole.log(cilvēki); //Masīvs

Jūs varat nekavējoties inicializēt masīvu ar noteiktu elementu skaitu:

Var lietotāji = new Array("Toms", "Bill", "Alise"); var cilvēki = ["Sems", "Džons", "Keita"]; konsole.log(lietotāji); // ["Toms", "Bills", "Alise"] console.log(cilvēki); // ["Sems", "Džons", "Keita"]

Varat definēt masīvu un pievienot tam jaunus elementus.

Var lietotāji = jauns Array(); lietotāji = "Toms"; lietotāji = "Kate"; konsole.log(lietotāji); // "Toms" konsole.log(users); //nenoteikts

Nav nozīmes tam, ka pēc noklusējuma masīvs tiek izveidots ar nulles garumu. Izmantojot indeksus, mēs varam aizstāt vienu vai otru elementu masīvā ar noteiktu indeksu.

garums

Lai uzzinātu masīva garumu, izmantojiet garuma rekvizītu:

Var auglis = jauns Array(); augļi = "āboli"; augļi = "bumbieri"; augļi = "plūmes"; document.write("Masīvā augļi " + fruit.length + " elements:
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Faktiski masīva garums būs pēdējā elementa indekss plus viens. Piemēram:

Var lietotāji = jauns Array(); // masīvā ir 0 elementi lietotāji = "Tom"; lietotāji = "Kate"; lietotāji = "Sams"; for(var i=0; i

Pārlūka izvade:

Toms Keita undefined undefined Sems

Neskatoties uz to, ka mēs nepievienojām elementus indeksiem 2 un 3, masīva garums šajā gadījumā būs skaitlis 5. Vienkārši elementiem ar indeksiem 2 un 3 būs nenoteikta vērtība.

Masīva kopēšana. šķēle ()

Masīva kopēšana var būt sekla vai sekla (sekla kopija) un dziļa (dziļa kopija).

Seklai kopēšanai pietiek ar to, ka mainīgajam piešķir cita mainīgā vērtību, kas glabā masīvu:

Var lietotāji = ["Toms", "Sems", "Bill"]; konsole.log(lietotāji); // ["Toms", "Sems", "Bills"] var cilvēki = lietotāji; // sekla kopēšana cilvēki = "Mike"; // mainīt otro elementu console.log(users); // ["Toms", "Maiks", "Bils"]

Šajā gadījumā mainīgais cilvēki pēc kopēšanas norādīs uz to pašu masīvu, uz kuru attiecas lietotāju mainīgais. Tāpēc, mainot elementus cilvēkos, mainīsies arī elementi lietotājiem, jo ​​patiesībā tas ir viens un tas pats masīvs.

Šāda uzvedība ne vienmēr ir vēlama. Piemēram, mēs vēlamies, lai mainīgie pēc kopēšanas norādītu uz atsevišķiem masīviem. Un šajā gadījumā varat izmantot dziļo kopēšanu, izmantojot slice() metodi:

Var lietotāji = ["Toms", "Sems", "Bill"]; konsole.log(lietotāji); // ["Toms", "Sems", "Bills"] var people = users.slice(); // dziļa kopija cilvēki = "Mike"; // mainīt otro elementu console.log(users); // ["Toms", "Sams", "Bills"] console.log(cilvēki); // ["Toms", "Maiks", "Bils"]

Šajā gadījumā pēc kopēšanas mainīgie norādīs uz dažādiem masīviem, un mēs varam tos mainīt atsevišķi vienu no otra.

Slice() metode ļauj arī kopēt daļu no masīva:

Var lietotāji = ["Toms", "Sems", "Bils", "Alise", "Keita"]; var cilvēki = lietotāji.slice(1, 4); konsole.log(cilvēki); // ["Sems", "Bils", "Alise"]

Slice() metodei tiek nodoti sākuma un beigu indeksi, kas tiek izmantoti vērtību izgūšanai no masīva. Tas nozīmē, ka šajā gadījumā atlase jaunajā masīvā notiek no indeksa 1 uz indeksu 4, neieskaitot. Un tā kā masīva indeksēšana sākas no nulles, jaunajā masīvā būs otrais, trešais un ceturtais elements.

push ()

Push () metode pievieno elementu masīva beigām:

Var auglis = ; augļi.push("āboli"); augļi.push("bumbieri"); augļi.push("plūmes"); fruit.push("ķirsis","aprikoze
"); document.write(augļi); // āboli, bumbieri, plūmes, ķirši, aprikozes

pop ()

Pop () metode noņem pēdējo elementu no masīva:

Var augļi = ["āboli", "bumbieri", "plūmes"]; var lastFruit = augļi.pop(); // izvilkt pēdējo elementu no masīva document.write(lastFruit + "
"); document.write("Masīvā augļi " + fruit.length + " elements:
"); for(var i=0; i ");

Pārlūka izvade:

Plūmes Augļu masīvā ir 2 elementi: āboli, bumbieri

maiņa ()

Metode shift() izgūst un noņem pirmo elementu no masīva:

Var augļi = ["āboli", "bumbieri", "plūmes"]; var firstFruit = auglis.shift(); document.write(firstFruit + "
"); document.write("Masīvā augļi " + fruit.length + " elements:
"); for(var i=0; i ");

Pārlūka izvade:

Āboli Augļu masīvā ir 2 elementi: bumbieri plūmes

unshift()

Metode unshift() pievieno jaunu elementu masīva sākumam:

Var augļi = ["āboli", "bumbieri", "plūmes"]; augļi.unshift("aprikozes"); dokuments.rakstīt(auglis);

Pārlūka izvade:

Aprikozes, āboli, bumbieri, plūmes

Elementa noņemšana pēc indeksa. salaist ()

Splice() metode noņem elementus noteiktā indeksā. Piemēram, noņemot elementus no trešā indeksa:

Var lietotāji = ["Toms", "Sems", "Bils", "Alise", "Keita"]; var izdzēsts = lietotāji.savienojums(3); console.log(dzēsts); // [ "Alise", "Kate" ] console.log(users); // [ "Toms", "Sems", "Bils" ]

Šķēles metode atgriež noņemtos elementus.

Šajā gadījumā dzēšana notiek no masīva sākuma. Ja nododat negatīvu indeksu, dzēšana tiks veikta no masīva beigām. Piemēram, noņemsim pēdējo elementu:

Var lietotāji = ["Toms", "Sems", "Bils", "Alise", "Keita"]; var izdzēsts = lietotāji.savienojums(-1); konsole.log(dzēsts); // [ "Kate" ] console.log(users); // [ "Toms", "Sems", "Bils", "Alise" ]

Metodes papildu versija ļauj norādīt beigu indeksu dzēšanai. Piemēram, izdzēsīsim pirmo līdz trešo indeksu:

Var lietotāji = ["Toms", "Sems", "Bils", "Alise", "Keita"]; var izdzēsts = lietotāji.savienojums(1,3); konsole.log(dzēsts); // [ "Sams", "Bills", "Alise" ] console.log(users); // [ "Toms", "Kate"]

Cita savienojuma metodes versija ļauj ievietot jaunus elementus dzēsto elementu vietā:

Var lietotāji = ["Toms", "Sems", "Bils", "Alise", "Keita"]; var deleted = users.splice(1,3, "Ann", "Bob"); konsole.log(dzēsts); // [ "Sams", "Bills", "Alise" ] console.log(users); // [ "Toms", "Anna", "Bobs", "Keita"]

Šajā gadījumā mēs izdzēšam trīs elementus no 1. līdz 3. indeksam un ievietojam divus elementus.

concat ()

Concat() metode tiek izmantota, lai apvienotu masīvus:

Var augļi = ["āboli", "bumbieri", "plūmes"]; var dārzeņi = ["tomāti", "gurķi", "kartupeļi"]; var produkti = augļi.concat(dārzeņi); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

Šajā gadījumā nav nepieciešams apvienot tikai viena veida masīvus. Iespējami dažādi veidi:

Var augļi = ["āboli", "bumbieri", "plūmes"]; dažādas cenas = ; var produkti = augļi.concat(cenas);

pievienoties ()

Join () metode apvieno visus masīva elementus vienā virknē:

Var augļi = ["āboli", "bumbieri", "plūmes", "aprikozes", "persiki"]; var fruitString = augļi.join(", "); document.write(fruitString);

Join() metode tiek nodota atdalītājs starp masīva elementiem. Šajā gadījumā kā atdalītājs tiks izmantots komats un atstarpe (", ").

kārtot ()

Metode sort() sakārto masīvu augošā secībā:

Var augļi = ["āboli", "bumbieri", "plūmes", "aprikozes", "persiki"]; fruit.sort(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Pārlūka izvade:

Aprikozes bumbieri persiki plūmes āboli

reverse()

Reverse () metode apvērš masīvu atpakaļ:

Var augļi = ["āboli", "bumbieri", "plūmes", "aprikozes", "persiki"]; augļi.reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Pārlūka izvade:

Persiki aprikozes plūmes bumbieri āboli

Kombinācijā ar metodi sort() varat kārtot masīvu dilstošā secībā:

Var augļi = ["āboli", "bumbieri", "plūmes", "aprikozes", "persiki"]; augļi.šķirot().reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Pārlūka izvade:

Āboli plūmes persiki bumbieri aprikozes

Elementa indeksa atrašana

Metodes indexOf() un lastIndexOf() atgriež elementa pirmās un pēdējās iekļaušanas indeksu masīvā. Piemēram:

Var augļi = ["āboli", "bumbieri", "plūmes", "āboli", "bumbieri"]; var firstIndex = augļi.indexOf("āboli"); var lastIndex = augļi.lastIndexOf("āboli"); var otherIndex = augļi.indexOf("ķirši"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1

firstIndex vērtība ir 0, jo pirmā rindas "āboli" iekļaušana masīvā ir indeksā 0, bet pēdējā ir indeksā 3.

Ja elements neatrodas masīvā, tad šajā gadījumā metodes indexOf() un lastIndexOf() atgriež vērtību -1.

katrs()

Metode every() pārbauda, ​​vai visi elementi atbilst noteiktam nosacījumam:

Var skaitļi = [ 1, -12, 8, -4, 25, 42 ]; funkcijas nosacījums(vērtība, indekss, masīvs) ( var rezultāts = false; if (vērtība > 0) ( rezultāts = patiess; ) atgriež rezultātu; ); var pagājis = skaitļi.katrs(nosacījums); dokuments.rakstīt(ieskaitīts); // viltus

Metodei every() tiek nodota funkcija, kas attēlo nosacījumu kā parametru. Šai funkcijai ir nepieciešami trīs parametri:

Funkcijas nosacījums (vērtība, indekss, masīvs) ( )

Vērtības parametrs apzīmē pašreizējo masīva elementu, kas tiek atkārtots, indeksa parametrs apzīmē šī elementa indeksu, un masīva parametrs nodod atsauci uz masīvu.

Šajā funkcijā mēs varam pārbaudīt, vai nodotā ​​elementa vērtība atbilst kādam nosacījumam. Piemēram, šajā piemērā mēs pārbaudām katru masīva elementu, lai redzētu, vai tas ir lielāks par nulli. Ja tas ir lielāks, mēs atgriežam vērtību true , tas ir, elements atbilst nosacījumam. Ja mazāk, tad atgriezt false - elements neatbilst nosacījumam.

Rezultātā, izsaucot metodi numbers.every(condition), tā atkārtojas cauri visiem skaitļu masīva elementiem un pa vienam nodod tos nosacījuma funkcijai. Ja šī funkcija visiem elementiem atgriež patieso vērtību, tad metode every() atgriež patieso vērtību. Ja vismaz viens elements neatbilst nosacījumam, tad metode every() atgriež false .

daži ()

Some() metode ir līdzīga katrai() metodei, tikai tā pārbauda, ​​vai vismaz viens elements atbilst nosacījumam. Un šajā gadījumā metode some() atgriež true . Ja masīvā nav neviena elementa, kas atbilstu nosacījumam, tiek atgriezts false:

Var skaitļi = [ 1, -12, 8, -4, 25, 42 ]; funkcijas nosacījums(vērtība, indekss, masīvs) ( var rezultāts = false; if (vērtība === 8) ( rezultāts = patiess; ) atgriež rezultātu; ); var pagājis = skaitļi.daži(nosacījums); // taisnība

filtrs ()

Filtra() metode, tāpat kā some() un every() , pieņem nosacījumu funkciju. Bet tajā pašā laikā tas atgriež to elementu masīvu, kas atbilst šim nosacījumam:

Var skaitļi = [ 1, -12, 8, -4, 25, 42 ]; funkcijas nosacījums(vērtība, indekss, masīvs) ( var rezultāts = false; if (vērtība > 0) ( rezultāts = patiess; ) atgriež rezultātu; ); var filtrētsSkaitļi = skaitļi.filtrs(nosacījums); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

Pārlūka izvade:

1 8 25 42

forEach() un map()

Metodes forEach() un map() atkārtojas pār elementiem un veic ar tiem noteiktas darbības. Piemēram, lai aprēķinātu skaitļu kvadrātus masīvā, varat izmantot šādu kodu:

Var skaitļi = [1, 2, 3, 4, 5, 6]; for(var i = 0; i "); }

Bet, izmantojot metodi forEach(), jūs varat vienkāršot šo konstrukciju:

Var skaitļi = [1, 2, 3, 4, 5, 6]; funkcija kvadrāts(vērtība, indekss, masīvs) ( var rezultāts = vērtība * vērtība; document.write("Cipara " + vērtība + " kvadrāts ir " + rezultāts + "
"); ); skaitļi.Katram(kvadrāts);

Metode forEach() ņem par parametru to pašu funkciju, kurā, atkārtojot elementus, tiek nodots pašreizējais iterējamais elements un ar to tiek veiktas darbības.

Metode map() ir līdzīga metodei forEach, tā kā parametrs ņem arī funkciju, kas veic darbības ar masīva elementiem, bet metode map() atgriež jaunu masīvu ar darbību rezultātiem ar masīva elementiem.

Piemēram, izmantosim kartes metodi, lai aprēķinātu skaitļu kvadrātus masīvā:

Var skaitļi = [1, 2, 3, 4, 5, 6]; funkcija kvadrāts(vērtība, indekss, masīvs) ( atgriešanās rezultāts = vērtība * vērtība; ); var squareArray = skaitļi.karte(kvadrāts); document.write(squareArray);

Funkcija, kas tiek nodota metodei map(), saņem pašreizējo iterējamo elementu, veic ar to darbības un atgriež kādu vērtību. Pēc tam šī vērtība nonāk iegūtajā squareArray

Šajā rakstā mēs apskatīsim standarta JavaScript masīvus ar skaitliskiem indeksiem. Masīvus deklarē, izmantojot kvadrātiekavas:

var augļi = ["Ābols", "Apelsīns", "Ēzelis"]

Lai izvilktu elementu, ievietojiet tā indeksu kvadrātiekavās. Pirmais rādītājs 0:

var augļi = ["Ābols", "Apelsīns", "Ēzelis"] alert(fruits) alert(fruits) alert(fruits)

Mēs varam arī iegūt JavaScript masīva garumu:

var augļi = ["Ābols", "Apelsīns", "Ēzelis"] brīdinājums(augļi.garums)

Hmm! Mēs izveidojām masīvu ar diviem augļiem un ēzeli. Tagad mums ir jānoņem ēzelis.

pop un push metodes

Pop metode JavaScript noņem elementu no masīva un atgriež to.

Šajā piemērā parādīts, kā no masīva tiek izgūts "Ēzelis".

var fruits = ["Ābols", "Apelsīns", "Ēzelis"] alert("Es noņemu "+fruits.pop()) // Tagad mums ir tikai ["Apple","Orange"] alert("Tagad masīva lielums : "+fruits.length) // ēzelis noņemts

Ņemiet vērā, ka pop maina pašu masīvu.

Pop līdzinieks ir push metode, kas masīvam pievieno elementu. Piemēram, mēs aizmirsām pievienot persiku:

var augļi = ["Ābols", "Apelsīns"] fruits.push("Persiks"); // tagad mums ir ["Apple", "Orange", "Peach"] brīdinājums ("Pēdējais elements:"+augļi)

1. Izveidojiet stilu masīvu ar elementiem " Džezs”, “Blūzs”;
2. Pievienojiet vērtību " Rokenrols«;
3. Aizstāt otro vērtību no beigām ar vērtību " Klasika". Jums vajadzētu iegūt masīvu: " Džezs”, ”Klasika”, ”Rokenrols" Kodam jādarbojas jebkuram masīva garumam;
4. Izgūstiet pēdējo vērtību no masīva un parādiet to, izmantojot brīdinājumu .

Risinājums

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // vai: styles = "Rock"n"Roll" // 3 styles = "Klasika " // 4 brīdinājums(styles.pop())

Shift/unshift metodes

Shift/Unshift metodes darbojas masīva beigās, taču varat arī izmantot Shift, lai pārvietotu elementus uz augšu ( masīva pirmā vērtība tiek noņemta, pārvietojot elementus). Unshift metode ļauj JavaScript pievienot elementu masīvam no beigām:

var fruits = ["Ābols", "Apelsīns"] var apple = fruits.shift() // tagad mums ir tikai ["Apelsīns"] fruits.unshift("Lemon") // tagad mums ir ["Citrons", " Apelsīns"] brīdinājums(augļi.garums) // 2

Gan pārslēgšanas, gan pārslēgšanas funkcija var darboties ar vairākiem elementiem vienlaikus:

var fruits = ["Ābols"] fruits.push("Orange","Peach") fruits.unshift("Pineapple","Lemon") // tagad masīvs izskatās šādi: ["Ananāss", "Citrons", "Ābols", "Apelsīns", "Persiks"]

Pašpārvaldīts uzdevums

Ierakstiet kodu, lai, izmantojot brīdinājumu, parādītu nejaušu vērtību no arr masīva:

var arr = ["Plūme","Apelsīns","Ēzelis","Burkāns","JavaScript"]

Piezīme. Kods nejauša skaitļa iegūšanai no minimālās līdz maksimālajai vērtībai (ieskaitot) ir šāds:

var rand = min + Math.floor(Math.random()*(maks.+1-min))

Risinājums

Mums ir jāizvelk nejaušs skaitlis no 0 līdz arr.length-1 (ieskaitot):

var arr = ["Plūme","Apelsīns","Ēzelis","Burkāns","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Atkārtošana masīvā

Programmā JavaScript iterācija caur masīvu tiek veikta, izmantojot for cilpu:

var augļi = ["Ananāss", "Citrons", "Ābols", "Apelsīns", "Persiks"] for(var i=0; i

Pašpārvaldīts uzdevums

Izveidojiet funkciju find(arr,value), kas atrod vērtību dotajā masīvā un atgriež indeksu vai -1, ja vērtība netiek atrasta.

Piemēram:

arr = [ "tests", 2, 1.5, false ] find(arr, "test") // 0 find(arr, 2) // 1 find(arr, 1.5) // 2 find(arr, 0) // -1

Risinājums

Iespējamais risinājums varētu izskatīties šādi:

funkcija find(masīvs, vērtība) (for(var i=0; i

Bet tas nav pareizi, jo == nenosaka atšķirību starp 0 un false.

Strādājot ar JavaScript masīviem, pareizāk ir izmantot ===. Turklāt jaunākajā ES5 standartā ir iekļauta funkcija Array#indexOf. Ar to mēs varam definēt šādu funkciju:

funkcija find(masīvs, vērtība) (if (masīvs.indexOf) return array.indexOf(value) for(var i=0; i

Vēl gudrāk būtu definēt atrašanu ar nosacījumu, lai pārbaudītu, vai indexOf metode pastāv.

Pašpārvaldīts uzdevums

Izveidojiet funkciju filterNumeric(arr), kas ņem masīvu un atgriež jaunu masīvu, kurā ir tikai skaitliskās vērtības no arr .

Piemērs tam, kā tam vajadzētu darboties:

arr = ["a", 1, "b", 2]; arr = filtrsNumeric(arr); // tagad arr =

Risinājums

Risinājums ir atkārtot masīvu un pievienot vērtības jaunam masīvam, ja tās ir skaitliskas.

pievienoties un sadalīties

Dažreiz jums ir nepieciešams ātrs veids, kā pārvērst JavaScript masīvu par virkni. Tam ir paredzēta savienošanas metode.

Tas savieno masīvu virknē, izmantojot doto atdalītāju:

var augļi = ["Citrons", "Ābols", "Apelsīns", "Persiks"]; var str = augļi.join(", "); brīdinājums(str);

Apgriezto konvertēšanu var viegli veikt, izmantojot sadalīšanas metodi:

var augļi = "Ābols, Apelsīns, Persiks"; var arr = augļi.split(","); // arr tagad satur ["Apple", "Orange", "Peach"] alert(arr);

Pašpārvaldīts uzdevums

Objekts ietver rekvizītu className, kurā ir klašu nosaukumi, atdalīti ar atstarpēm:

Uzrakstiet funkciju addClass(obj, cls), kas pievieno klasi cls , bet tikai tad, ja tā neeksistē:

ddClass(obj, "new") // obj.className="atvērt izvēlni new" addClass(obj, "open") // bez izmaiņām (klase jau pastāv) addClass(obj, "me") // obj.className= "atvērt izvēlni jauns es" brīdinājums(obj.className) //

Risinājums

Klases nosaukums un cilpa ir jāsadala daļās. Ja klase netiek atrasta, tā tiek pievienota.

Cilpa ir nedaudz optimizēta, lai palielinātu veiktspēju:

funkcija addClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) return ) elem.className += " "+cls ) var obj = ( className: "open menu" ) addClass(obj, "new") addClass(obj, "open") alert(obj.className) // atvērt izvēlni jauns

Iepriekš minētajā piemērā mainīgais c ir definēts cilpas sākumā, un tā pēdējais indekss ir iestatīts uz i .

Pati cilpa tiek apstrādāta pretējā virzienā, beidzas ar nosacījumu i>=0. Jo i>=0 ir ātrāk pārbaudāms nekā i . Kas JavaScript paātrina meklēšanu masīvā.

Garuma izmantošana masīva apgriešanai

Izmantojot garuma rekvizītu, varat saīsināt masīvu šādi:

Jūs norādāt garumu, un pārlūkprogramma saīsina masīvu.

Masīvs ir objekts, ko tas nozīmē?

Faktiski JavaScript programmā masīvs ir objekts, kas komplektā ar automātisku garuma iestatījumu un īpašām metodēm.

Tas atšķiras no jēdziena citās valodās, kur masīvi attēlo blakus esošu atmiņas segmentu. Tas atšķiras arī no rindas vai steka, kuras pamatā ir saistītie saraksti.

Neciparu masīva atslēgas

Taustiņi ir cipari, taču tiem var būt jebkurš nosaukums:

arr = arr = 5 arr.prop = 10 // nedariet to

JavaScript masīvi ir hash tabulas, kurām ir veiktspējas priekšrocības, bet arī daži trūkumi.

Piemēram, push/pop darbojas tikai masīva visattālākajos elementos, tāpēc tie ir neticami ātri.

push darbojas tikai ar beigām:

var arr = ["Mans", "masīvs"] arr.push("something") alert(arr) // virkne "masīvs"

Shift/Unshift metodes ir lēnas, jo tām ir jāmaina viss masīvs. Savienošanas metode var izraisīt arī numerācijas izmaiņas:

Tātad pārslēgšana/izslēgšana ir lēnāka nekā push/pop . Jo lielāks ir masīvs, jo ilgāks laiks nepieciešams JavaScript, lai kārtotu masīvu.

Pašpārvaldīts uzdevums

Kāds būs rezultāts? Kāpēc?

arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // ?

Risinājums

Tā kā masīvi ir objekti, arr .. patiesībā ir metodes izsaukums objektam, piemēram, obj metodi:

arr() // tāds pats kā arr() // sintaktiski nepareizs, bet konceptuāli tas pats: arr.2() // pārrakstīts tādā pašā stilā kā obj.method() this = arr šajā gadījumā tiek nodots funkcijai, tātad tiek izdrukāts arr saturs. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",function

Reti masīvi, garuma apraksts

Garuma rekvizīts ļauj iegūt nevis JavaScript masīva lielumu, bet gan pēdējo indeksu + 1. Tas ir svarīgi, ja mēs runājam par retiem masīviem ar “starpībām” indeksos.

Nākamajā piemērā tukšajiem augļiem pievienosim divus elementus, bet garuma vērtība paliks 100:

var fruits = // tukšs masīvs augļi = "Persiku" augļi = "Ābolu" brīdinājums(fruits.length) // 100 (bet masīvā ir tikai 2 elementi)

Ja mēģināt izvadīt retu masīvu, pārlūkprogramma atgriezīs trūkstošās indeksa vērtības kā tukšus elementus:

var augļi = // tukšs masīvs augļi = "Persiku" augļi = "Ābolu" brīdinājums(augļi) // ,Persiks,Ābols (vai kaut kas tamlīdzīgs)

Bet masīvs ir objekts ar divām atslēgām. Trūkstošās vērtības neaizņem vietu.

Reti masīvi uzvedas dīvaini, ja tiem tiek lietotas masīvu metodes. Viņiem nav ne jausmas, ka trūkst indeksu:

var augļi = augļi = "Persiku" augļi = "Ābols" alert(fruits.pop()) // pop "Apple" (uz indeksu 9) alert(fruits.pop()) // pop an unspecified element (uz indeksu 8 )

Centieties izvairīties no retiem masīviem. Jebkurā gadījumā viņu metodes nedarbosies normāli. Tā vietā izmantojiet objektu.

Izņemšana no masīva

Kā mēs zinām, masīvi ir objekti, tāpēc mēs varētu izmantot dzēšanu, lai noņemtu vērtību:

var arr = ["Aiziet", "uz", "mājās"] delete arr // tagad arr = ["Aiziet", undefined, "home"] alert(arr) // nav definēts

Var redzēt, ka vērtība ir noņemta, bet ne tā, kā mēs vēlētos, jo masīvā ir nenorādīts elements.

Dzēšanas operators noņem atslēgas-vērtības pāri, un viss. Protams, tā kā masīvs ir tikai hash, noņemtā elementa pozīcija kļūst nenoteikta.

Visbiežāk mums ir jānoņem elements, neatstājot “caurumus” starp indeksiem. Ir vēl viena metode, kas mums to palīdzēs.

savienojuma metode

Savienošanas metode var noņemt elementus un aizstāt tos JavaScript daudzdimensiju masīvos. Tās sintakse ir:

arr.splice(indekss, deleteCount[, elem1, ..., elementN])

Noņem elementu deleteCount, sākot ar indeksu, un pēc tam tā vietā ievieto elem1, ..., elemN.

Apskatīsim dažus piemērus:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // noņemt 1 elementu, kas sākas ar indeksu 1 alert(arr.join(",")) // ["Go " , "mājas"] (noņemts 1 elements)

Tātad jūs varat izmantot savienojumu, lai noņemtu vienu elementu no masīva. Masīva elementu numuri tiek pārvietoti, lai aizpildītu vietu:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // noņemt 1 elementu, sākot no indeksa 0 alert(arr) // "uz" kļuva par pirmo elementu

Šis piemērs parāda, kā nomainīt elementus:

Savienošanas metode atgriež noņemto elementu masīvu:

var arr = ["Iet", "uz", "mājas", "tagad"]; // noņemt pirmos 2 elementus var noņemts = arr.splice(0, 2) alert(removed) // "Go", "to"<-- массив удаленных элементов splice может вставлять элементы, задайте 0 для deleteCount. var arr = ["Go", "to", "home"]; // со второй позиции // удаляем 0 // и вставляем "my", "sweet" arr.splice(2, 0, "my", "sweet") alert(arr) // "Go", "to", "my", "sweet", "home"

Šajā metodē var izmantot arī negatīvu indeksu, kas tiek skaitīts no masīva beigām:

var arr = // elementam -1 (priekšpēdējais) // noņemt 0 elementus, // un ievietot 3 un 4 arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

Pašpārvaldīts uzdevums

Objektā ir rekvizīts className, kurā ir klašu nosaukumi, atdalīti ar atstarpēm:

var obj = (className: "atvērt izvēlni")

Uzrakstiet funkciju removeClass(obj, cls), kas noņem klasi cls, ja tā ir dota:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // bez izmaiņām (nav nevienas klases, ko noņemt)

Risinājums

Klases nosaukums ir jāsadala daļās un jāiet cauri šīm daļām. Ja tiek atrasta atbilstība, tā tiek noņemta no JavaScript objektu masīva un pēc tam pievienota beigās.

Nedaudz optimizēsim šo:

funkcija removeClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( klasesNosaukums: "atvērt izvēlni" ) removeClass(obj, "open") removeClass(obj, "blabla") alert (obj.className) // izvēlne

Iepriekš minētajā piemērā mainīgais c ir iestatīts cilpas sākumā un i ir iestatīts uz tā pēdējo indeksu.

Pati cilpa iet pretējā virzienā, beidzas ar nosacījumu i>=0. Tas tiek darīts, jo i>=0 tiek pārbaudīts ātrāk nekā i . Kas paātrina īpašumu meklēšanu c .

šķēles metode

Jūs varat izvilkt daļu no masīva, izmantojot slice(begin[, end]) metodi: var arr = ["Kāpēc", "mācīties", "JavaScript"]; var arr2 = arr.slice(0,2) // aizņem 2 elementus, sākot ar 0 alert(arr2.join(", ")) // "Kāpēc, mācieties"

Lūdzu, ņemiet vērā, ka šī metode nemaina elementu skaitu masīvā JavaScript, bet gan kopē daļu no tā.

Varat izlaist otro argumentu, lai visi elementi sākas ar noteiktu indeksu:

var arr = ["Kāpēc", "mācīties", "JavaScript"]; var arr2 = arr.slice(1) // ņem visus elementus, sākot no 1 alert(arr2.join(", ")) // "learn, JavaScript"

Metode atbalsta negatīvus indeksus, tāpat kā String#slice .

apgrieztā metode

Vēl viena noderīga metode ir pretēja. Pieņemsim, ka es vēlos iegūt pēdējo domēna daļu, piemēram, " com"no" mana.vietne.com" Lūk, kā to izdarīt:

var domēns = "mana.vietne.com" var last = domain.split(".").reverse() alert(pēdējais)

Ņemiet vērā, ka JavaScript masīvi atbalsta sarežģītu sintaksi (reverse()), lai izsauktu metodi un pēc tam izgūtu elementu no iegūtā masīva.

Varat izveidot garākus zvanus, piemēram, reverse() 0] arr.sort() alert(arr) // 1, 15, 2

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 pēc noklusējuma izmanto leksikogrāfisko secību.