Divdimensiju masīvs JavaScript. Masīvs Trivial js masīvs

• I. Atsauces masīvu saraksts
  1. katrai metodei un vietējām metodēm
  2. cilpai
  3. Pareizais veids, kā izmantot for ... in cilpa
  4. priekš ... no cilpas (netieši iteratora mainīgais)
  5. Skaidri izmantojot iteratoru
• 1. Pīti veidi, kā atkārtot atsauces masīvus
  2. Konvertēšana uz atsauces masīvu
  3. Cieņa pret viconnanny vidus objektiem

I. Atsauces masīvu saraksts

Pašlaik ir trīs veidi, kā atkārtot atsauces masīva elementus:

1. metode Array.prototype.forEach;
2. klasika cilpai;
3. "Pareizais" pamudinājums ir paredzēts ... cilpā.

Turklāt līdz ar jaunā ECMAScript 6 (ES 6) standarta parādīšanos ir vēl divi veidi:

1. for ... of loop (netieši iteratora mainīgais);
2. nepārprotami ir iteratora izvēle.

1. Metode forEach un vietējās metodes

It kā jūsu projekts papildina ECMAScript 5 (ES5) iespēju standartu, varat pārbaudīt vienu jaunu funkciju — metodi forEach.

Vikoristanas piemērs:
var a = [ "a", "b", "c"]; a.forEach(funkcija(ieraksts)(console.log(ieraksts);));
ForEach izmanto pārlūkprogrammām paredzēto emulācijas bibliotēku es5-shim, lai nevarētu sākotnēji atbalstīt šo metodi. Pirms tiem var redzēt IE 8 un vairāk agrīnās versijas, kas joprojām ir uzvarošas līdz šai dienai.

Pirms forEach pass ir tie, kuriem nav jānorāda lokālās izmaiņas, lai saglabātu plūsmas elementa indeksu un vērtību masīvā, smirdīgās skaidiņas automātiski tiek nodotas atzvanīšanas funkcijai kā argumenti.

Ja jūs var traucēt iknedēļas atzvanīšana ādas elementam, nelielieties un izlasiet to.

Katram uzdevumam iterācijai pār visiem masīva elementiem, bet ES5 ievieš vēl dažas pamata metodes visu vai jebkuru citu elementu iterēšanai, kā arī rakstīšanu, kad runa ir par kādu no tiem:

• ik — turn true, tāpēc ādas elementam atzvanīšanas masīvs pārvērtīs vērtību par patiesu.
• daži - pagrieziet patiesu, ja vēlaties viena atzvanīšanas masīva elementa vērtību pārvērst par patiesu.
• filtrs - izveidojiet jaunu masīvu, kurā ir iekļauti tie izvades masīva elementi, kuriem atzvanīšana kļūst patiesa.
• karte - izveido jaunu masīvu, ko saskaita, ko dzemdēt! atzvani.
• samazināt - samazināt masīvu līdz vienai vērtībai, atzvanīšana pēc numura uz masīva ādas elementu, sākot no pirmā (varbūt korekcija masīva elementu summas skaitīšanai un citām apakšsoma funkcijām).
• ReductionRight — darbojas līdzīgi, lai samazinātu, bet atkārtojas pār elementiem apgrieztā secībā.

2. For cilpa

Vecs labs stūrei:

Var a = [ "a", "b", "c"]; var indekss; priekš (indekss = 0; indekss< a.length; ++index) { console.log(a); }
Ja masīva garums ir nemainīgs visā ciklā un pats cikls ir kritisks attiecībā uz produktivitātes paplašināšanu līdz kodam (kas ir mazs), tad jūs varat iegūt “optimālāku” versiju pēc iespējas īsākā garumā. masīvs:

Var a = [ "a", "b", "c"]; var indekss, len; for (indekss = 0, len = a.garums; indekss< len; ++index) { console.log(a); }
Teorētiski šis kods ir vainojams nedaudz vairāk, zemāk priekšā.

Ja elementu uzskaitīšanas secība nav svarīga, tad optimizācijas plānā joprojām varat virzīties tālāk un izmantot to kā izmaiņas, lai saglabātu pārējo masīvu, mainot uzskaites secību uz apgrieztu:

Var a = [ "a", "b", "c"]; var indekss; for (index = a.length - 1; index >= 0; --index) (console.log(a);)
Prote, mūsdienu JavaScript dzinējos līdzīgas spēles ar optimizāciju neizklausās kā nekas.

3. Pareiza for ... in cilpas lietošana

Lai jūs būtu laimīgs, uzvarot cilpas for..., atcerieties, ka iterācija masīvos nav tā, kurai ir paredzēti uzdevumi. Īpaši plašā vidē for ... in cilpa sakārto NEVIS masīva indeksu, bet uzskaita objekta jaudu.

Prote, tādās vipadkās, piemēram, šķirojot pa izkaisītajiem masīviem, par ... in var šķist brūns, jo to var aizsniegt tikai ieejot, kā redzams zemāk esošajā dibenā:

// a - masīva paplašināšana var a =; a = "a"; a = "b"; a = "c"; for (var key in a) (if (a.hasOwnProperty (key) && /^0$|^\d*$/.test(key) && atslēga<= 4294967294) { console.log(a); } }
Šajā lietojumprogrammā cikla ādas iterācijā tiek veiktas divas pārskatīšanas:

1. kaut kas tāds, ka masīvam var būt jauda atslēgas nosaukumā (neattiecas no pirmā prototipa).
2. tad šī atslēga ir rinda, kas aizstās vesela skaitļa desmito ierakstu, kura vērtība ir mazāka par 4294967294. Vai ņemat pārējo skaitļa daļu? Piešķiršana masīva indeksam ES5, kas parāda, kurš ir lielākais indekss, kas var būt masīva pamatelements: (2 ^ 32 - 2) = 4294967294.

Acīmredzot šādas atkārtotas pārbaudes notiek pēdējās stundas laikā cikla beigās. Ale, citā masīvā šī metode ir efektīvāka, nolaidiet for cilpu, tikai tie elementi, kas ir skaidri norādīti masīvā, tiek sakārtoti vienādi. Tātad lietojumprogrammā kopā būs 3 iterācijas (indeksiem 0, 10 un 10000) - pret 10001 for cilpā.

Lai nerakstītu tik apgrūtinošu kodu ādas pārrakstīšanai, ja nepieciešams kārtot masīvu, varat to sakārtot izskata un sajūtas funkcijā:

Funkcija arrayHasOwnIndex (masīvs, atslēga) (atgriež array.hasOwnProperty (atslēga) && /^0$|^\d*$/.test(atslēga) && atslēga<= 4294967294; }
Tad cikla korpuss ar dibenu ievērojami paātrinās:

For (key in a) (if (arrayHasOwnIndex (a, key)) (console.log (a);))
Pārskatītais labojumu kods ir universāls, derīgs visiem veidiem. Bet jaunā vietā var pārspēt īsāko variantu, ja vēlies formāli un nezini pareizo, bet, tas nav mazāk, tas ir piemērots lielākai versijai:

For (key in a) (if (a.hasOwnProperty (key) && String (parseInt (key, 10)) === key) (console.log(a);))

4. Cilpa ... no (netieši iteratora mainīgais)

ES6, lai gan joprojām ir melnā statusā, ir vainīgs iteratoru ieviešanā JavaScript.

iterators - tse protokola ieviešana objektā, kas nosaka standarta veidu vērtību secības noņemšanai (galīgā vai nesadalītā).
Iterators - viss objekts, kurā tiek piešķirta nākamā () metode - funkcija bez argumentiem, kas pagriež objektu ar divām pakāpēm:

1. done (būla) — pieņem vērtību true, kas nozīmē, ka iterators ir sasniedzis iterētās secības beigas. Citā gadījumā vērtība var būt nepatiesa.
2. vērtība — iestata vērtību, kas jāpagriež iteratoram. To var nepiešķirt (dienas laikā), jo izdarītā spēks var būt patiess.

Bagāts ar topošiem objektiem, t.sk. spravzhnі masivi, mayut iteratori par zamovchuvannyam. Vienkāršākais veids, kā aizpildīt iteratoru atsauces masīvos, ir iegūt jaunu par ... no konstrukcijas.

victoria krājumi ... no:

Varval; var a = [ "a", "b", "c"]; for(val of a)(console.log(val);)
Lietojumprogrammā, kurā atrodas kursors, for ... of cilpa netieši izsauc masīva objekta iteratoru, lai izgūtu masīva ādas vērtību.

5. precīza iteratora izguve

Iteratorus var arī savīti un nepārprotami, tomēr šādā veidā kods kļūst ievērojami salokāmāks, atbilstoši ciklam for .... Izskatās šādi:

Var a = [ "a", "b", "c"]; var it = a.entries(); var ieraksts; while(!(ieraksts = it.next()).done)(console.log(entry.value);)
Šajā piemērā metode Array.prototype.entries pārvērš iteratoru, ko izmanto, lai izgūtu masīva vērtību. Ievades.vērtības ādas iterācijā aizstājiet formas [atslēga, vērtība] masīvu.

II. Masīvam līdzīgu objektu uzskaitīšana

Pareizo masīvu noziegumi, JavaScript tie ir izmērīti šādi masīviem līdzīgi objekti . Ar pareizajiem їх masīviem, lai nosauktu tos, kas smird pēc jaudas garuma un jaudas, ar skaitļu nosaukumiem, kas atbilst masīva elementiem. Kā piemēru varat nosaukt DOM kolekciju NodeList un argumentu pseidomasīvus, kas pieejami jebkuras funkcijas/metodes vidū.

1. Vairāki veidi, kā uzskaitīt atsauces masīvus

Vismaz lielāko daļu, bet ne visus, atsauces masīvu uzskaitīšanas veidus var apturēt, lai uzskaitītu masīvam līdzīgus objektus.

Par un for ... konstrukcijas var tikt nodotas masīvam līdzīgiem objektiem tieši tāpat kā parastajos masīvos.

ForEach un citas metodes Array.prototype arī prasa masīvam līdzīgus objektus. Par kuru nepieciešams čivināt Function.call vai Function.apply.

Piemēram, ja vēlaties nodot forEach objekta Mezgla mezglu autoritātei, varat to izdarīt šādi:

Array.prototype.forEach.call (node.childNodes, funkcija (child) (// darbs ar bērnu objektu));
Atlases atkārtošanas ērtībai varat izmantot metodi Array.prototype.forEach okremіy zminnoї i vikoristovuvat її її skorochenna:

// (Ņemiet vērā, ka viss tālāk norādītais kods ir vienā tvērumā) var forEach = Array.prototype.forEach; // ... forEach.call (node.childNodes, function (child) (// darbs ar bērnu objektu));
Ja iterators ir iterators masīvam līdzīgā objektā, tad to var tieši vai netieši izsekot, lai uzskaitītu objektu tādā pašā veidā kā parastajiem masīviem.

2. Konvertēšana uz atsauces masīvu

Ir arī viens, vēl vienkāršāks veids, kā uzskaitīt masīvam līdzīgu objektu: pārveidot to par atsauces masīvu un mēģināt atrast labāku veidu, kā uzskaitīt atsauces masīvus. Transformācijai var pagriezt universālo metodi Array.prototype.slice, kuru var pielīmēt pie jebkura masīva veida objekta. Cīnīties ir vēl vieglāk, kā parādīts tālāk esošajā piemērā:

Var trueArray = Array.prototype.slice.call(arrayLikeObject, 0);
Piemēram, ja vēlaties pārvērst NodeList kolekciju par atsauces masīvu, jums būs nepieciešams kaut kas līdzīgs šim:

Var divs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
Atjaunināt: Kā teikts rock un torbasow komentāros, ES6 Array.prototype.slice var aizstāt ar lielāku metodi Array.from.

3. Cieņa pret vikonānijas vidus objektiem

Ja instalējat Array.prototype metodes objektos vidē (piemēram, DOM kolekcijās), tad jūs esat atbildīgs par to, ka šo metožu pareiza darbība netiek garantēta visās vidēs (arī pārlūkprogrammās). Ir nepieciešams saglabāt konkrēta objekta uzvedību noteiktā vidē, kas ir precīzāk, jo šajā objektā tiek realizēta abstraktā darbība HasProperty. Problēma ir tā, ka ES5 standarts pats par sevi pieļauj objekta nepareizas darbības iespēju pēc noklusējuma pirms operācijas (sadaļa §8.6.2).

Tāpēc svarīgi ir pārbaudīt Array.prototype metožu robotu ādas vidē (pārlūkā), kurā plānots testēt savu aplikāciju.

Pirmajā rakstā mēs runājām par tām pašām lietām un to, kā ar viņu strādāt. Šajos rakstos mēs runāsim par bagātīgs masīvs.

Tse masīvs, kurā ir viens vai vairāki elementi, arī ir masīvi. Zalezhno vіd glibini goloshennya, zokrema vіn var saukt divdimensiju masīvs(2 vienādi) vai triviāls masīvs(3 rubļi) vai Chotirivimirnim(4 rubļi) un līdz šim.

Vispopulārākais pēc vienas pasaules masīva, kas ir vispopulārākais no divu pasauļu masīva. Tas pats yogo, vivchimo vairāk ziņojumu.

Tāpat kā bahīts, arī divu pasauļu masīva elementi ir vienas pasaules masīvi. Yakbi tsі odnomirnі masīvi atriebīgi masīvi, tad masīvs arr buv bi jau ir triviāls.

Piemēram, izveidosim trīs vienkāršus masīvus un atcerēsimies tos. Mēs atceramies pirmo ar sapārotiem cipariem, otru ar nepāra numuriem, bet trešo ar pietiekamiem cieņas apliecinājumiem.

// Apdullināt trīs tukšus masīvus var evenNumbers = new Array (); // Mainīt k - masīva indeksam evenNumbers var k = 0; var nepāra skaitļi = new Array(); // Mainīt n - masīva indeksam oddNumbers var n = 0; var dati = new Array( "automašīna", "lidmašīna", patiess, 89, "m"); // Mēs aizpildīsim masīvu evenNumbers ar puišu numuriem (var i = 1; i

Lai pabrīnītos par to, kas atrodas masīva vidū, var paātrināt ar tādu rīku kā konsole.

Piemēram, mēs vēlamies saskaņot masīvu ar nepāra skaitļiem nepāra skaitļiem. Kam tālāk esošajā kodā mēs rakstām šādu rindu:

Console.log(nepāra skaitļi);

Lai uzlabotu rezultātu, ir jāatzīst konsole pārlūkprogrammā. Pārlūkā Google Chrome tam vajadzētu darboties šādi: ar peles labo pogu noklikšķiniet uz sāniem un konteksta izvēlnē atlasiet atlikušo opciju "Skatīt kodu", pēc tam atlasiet inspektoru. Angļu valodas versijā šī opcija tiek saukta par pārbaudi.

І zemāk parādīsies mazumtirgotāja rīkjosla. Jums jāiet uz cilni Konsole.

Tagad par to izveidot divu pasauļu masīvu, Ir nepieciešams izrunāt jogu un pievienot jaunajam pasaules masīvam, it kā viņi darītu vairāk.

// Izlaist divdimensiju masīvu twoDimens un atgriezt to var twoDimens = new Masīvs (pāra numuri, nepāra skaitļi, dati); konsole.log(twoDimens);

Apskatīsim konsoli šī masīva vietā.

divu pasauļu masīva uzskaitījums

Iesākumam mācīsimies kā pievērsties divu pasauļu masīva elementiem.

Tāpat kā ar atsevišķiem masīviem, jūs varat cīnīties ar elementiem pēc to indeksiem.

Piemēram, parādīsim elementu ar indeksu 3 nepāra skaitļu masīvā (nepāra skaitļi). Vienas pasaules masīva nepāra skaitļu indekss divu pasaules masīvā diviDimensions no pārējiem (1).

Document.write( "Vienums indeksā 3 uz nepāra skaitļu masīvu nepāra skaitļi ir vairāk:" + twoDimens); // elements: 7

TwoDimens masīvā mēs pārietam uz elementu ar indeksu 1. Elements, kas atrodas zem indeksa, ir oddNumbers masīvs. І šajā masīvā mēs jau ejam uz elementu ar indeksu 3, kas ir 7. numurs.

Tagad ķersimies pie ēdiena. kā atkārtot divu pasauļu masīvu.

Divu pasauļu masīva uzskaitīšana, lai cīnītos par sagrauto cikla palīdzību. Piemēram, apskatīsim mūsu twoDimens masīvu.

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

Elements ar indeksu "+I+" "+j+" dorīvnyuє: "+TwoDimens[i][j]+"

"); } }

Pirmajā ciklā mums ir jāuzskaita pats twoDimens masīvs. Citā ciklā ir nepieciešams arī uzskaitīt pašu elementu (masīvu). No otras puses, mainiet i uz 0. Uz to citā ciklā, no otras puses, mēs izšķirsim pirmo masīvu patNumbers, kuram var būt indekss 0. Un jau cita cikla vidū mēs pāriesim uz šī masīva elementi. Šādā secībā: diviDimensions [j]. Tas mainās no 0 uz j uz masīvu evenNumbers.

Pēc pirmā masīva elementu atkārtošanas, pārejot uz pirmo ciklu, mēs palielinām izmaiņu i un pārejam uz cita nepāra skaitļu masīva uzskaitīšanu, kura indekss var būt 1. Tādējādi ass mēģina uzskaitīt ādas elementu. no divdimensiju twoDimens masīva.

Tagad apskatīsim šī uzskaitījuma rezultātu:

Ass un viss par to, ko es vēlos pastāstīt šajā rakstā. Tagad jūs zināt, kā izveidot divu pasauļu masīvu, kā pievērsties divu pasauļu masīva elementiem un kā kārtot divu pasauļu masīvu. Esmu pārliecināts, ka viss bija skaidrs. Es novēlu jums lielus panākumus!

Zvēru visiem, kam šāda tēma interesē, jo JavaScript ir bagāts ar masīviem un šķirošanu. Pašreizējā publikācijā es centīšos izvērst šo tēmu visās detaļās.

Tāpēc, izlasot rakstu, jūs zināt, ka tīmekļa pielikumos ir bagātīgas uzvaras, kā rodas smirdas un kā tos var kontrolēt un šķirot. Sāksim!

Kā rodas bagātas masas un kāpēc vajadzīga smirdoņa?

Lai vālītes varto uzminētu, kā tiek izveidots lieliskais viendimensijas masīvs.

masīvs =

Un tagad atcerieties, ka bagātīgs masīvs ir masīvu masīvs. Pagaidīšu, izklausās pēc tautoloģijas. Tomēr izlasiet paziņojumu vēlreiz. Patiešām, bagāts masīvs sastāv no viena skaita ieguldījumiem jaunā.

Apskatīsim situāciju. Uz vālītes pēc iespējas ātrāk ievadiet savu vārdu, un pēc darba pabeigšanas ekrānā tiks parādīta reitingu tabula ar gravētāju vārdiem un їх ierakstiem.

Skaidrs, ka šāda informācija tiek apkopota datubāzē. Bet, ja mēs її vytyagaєmo no datu bāzes, tad ņemsim bagātīgu masīvu. Aje ādas aplikācijā ietaupa pieteikšanās smagumu un iegūto punktu skaitu.

Paskatieties uz visu, jūs būsiet uzbrūkošs rangs:

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

Tāpat kā Bahite, informāciju var saglabāt dažādi. Tse var būt і rindas, і cipari, і navit. Iespējams, ka masīvā nav ierakstīšanas.

Kad jūs dodaties uz elementiem, jūs saņemat caur apakšoperatoru.

Lai labotu materiālu, analizējiet nelielu programmu.

rezultāti =

Masīvi jāaizpilda ar roku, lai saglabātu sarežģītu datu secību to apstrādes laikā. Līdz tam trenējieties ar viņiem jau parocīgi un ar ko viņu griezumu ātrums tiek veikts līdz templim.

Datu kārtošanas veidi

Masīviem JavaScript, pāreja uz izsaukuma metodi kārtot (). Dāņu instruments ir pārāk mīksts. Tūlīt paskaidrošu, kāpēc.

Ja atlasāt metodi bez parametriem, apakšmasīvs tiks automātiski sakārtots pēc pirmā elementa alfabētiskā secībā. Jā, ar vikliku rezultātus.kārtot () Objekts tiks sakārtots, un ass izskatīsies šādi:

Oleksijs, 124

Markuss, 333

Nataša, 211 gads

Un, ja atceraties, ka ādā ir deponēts elementu un detaļu masīvs, mēs redzēsim:

124, Oleksijs

211, Nataša

333, Markuss

Tajā pašā laikā izlīdzināšanai visi laika elementi tiek pārveidoti rindās.

Ja jums ir nepieciešama funkcija, kas kārto elementus nestandarta veidā, varat to uzrakstīt pats un nodot to kā parametru kārtot (). Jebkuru varto melu gadījumā, kas tiek atpazīts par koristuvach, ir jāpagriež funkcija:

• pozitīvs skaitlis (galvenokārt izvēlieties 1), jo pirmais elements seko otram, ja tas ir vienāds;
• negatīvs skaitlis (teiksim -1), it kā cits elements būtu vainīgs, sekojot pirmajam;
• nulle, tāpat kā divi, vienādības vērtības tiek apgrieztas.

Jaku muca pieņemsim vālīšu masīvu rezultātusšķirots brillēm. Kāpēc rezultāti tiks sakārtoti no lielākā uz mazāko. To var īstenot divos veidos.

Pirmajā variantā mainīju šķirošanas loģiku, tāpēc situācijā, ja vajag skaitli pagriezt pozitīvi, griežu negatīvi un apgriezti.

Ierakstu tabula:

Un otrā ceļa ass, atstājot šķirošanas loģiku ar zemgriezes momentu, ale vikoristov, pievienojot papildu metodi - reverse(). Kā redzams no nosaukuma, reverss maina elementu nodošanas secību pagarinājumam.

Tāpēc kārtošanas () funkcija izskatīsies kā gaidāmais rangs:

1 2 3 4 5

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

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

Un nākamās ass ir pievienot augstāku metodi.

Visnovok tiek veikta līdzīgā veidā.

Es vēlos jums atdot cieņu par vienu svarīgu brīdi. Mainot šīs funkcijas, visas izmaiņas tiek ņemtas no masīva, līdz tās apstājas. Šādā secībā, ja nepieciešams saglabāt pirmo datu izskatu, izveidojiet kopiju un pēc tam rediģējiet to vēlreiz.

Nu, ass I un rozpovs par bagātīgiem masīviem un to šķirošanu. Ja esi pagodināts ar kādu rakstu, tad abonē emuāru un lasi citas publikācijas. Es būšu vdyachny pārpublicēšanai. Uz drīzu redzēšanos!

Boo!

Ar cieņu Romāns Čuešovs

masivi

masīvs- tiek pasūtīta vērtību kolekcija. Vērtības masīvā sauc par elementiem, un ādas elementu raksturo skaitliskā pozīcija masīvā, ko sauc par indeksu. Masīvi JavaScript kustībās nav rakstīti: masīva elementi var būt jebkura veida mātes, un dažādi viena un tā paša masīva elementi var būt dažāda veida mātes. Masīva elementus var saukt par objektiem vai citiem masīviem, kas ļauj izveidot saliekamas datu struktūras, piemēram, objektu masīvus un masīvu masīvus.

Masīvu indekss JavaScript kustībās sākas no nulles, un tiem tiek izmantoti 32 bitu veseli skaitļi - pirmais masīva elements var būt indekss 0. nav nepieciešams atšifrēt masīvu paplašināšanas fiksāciju, kad tie tiek izveidoti, vai atkārtoti izplatīt atmiņu, mainot paplašinājumus.

Masīvi JavaScript valodā - objektu forma ir specializēta, un masīvu indeksi nozīmē trīs reizes vairāk, nolaidiet tikai iestāžu nosaukumus, jakі aiz lieliem skaitļiem.

masīvu izveide

Vienkāršāk ir izveidot masīvu, izmantojot literālu, kas ir vienkāršs ar komati atdalītu elementu saraksts masīvā kvadrātveida lokos. Vērtības masīva literālē nav saistītas ar valodas konstantēm - tās var būt dažādas, ieskaitot objektu literāļus:

var tukšs =; // Tukšs masīvs var numuri =; // Masīvs ar 5 ciparu elementiem var misc = [1.1, true, "a",]; // 3 dažāda veida elementi + gala koma var base = 1024; var tabula =; // Masīvs ar izmaiņām var arrObj = [,]; // 2 masīvi vidū, lai slaucītu objektus

Masīva literālā sintakse ļauj ievietot neo-valodas pabeigtāju, tāpēc literālais [,] atbilst masīvam ar diviem elementiem, nevis trim.

Labākais veids, kā izveidot masīvu, ir izmantot dizainera wiki masīvs(). Izsaukšanu konstruktoram var veikt trīs dažādos veidos:

Clicky konstruktors bez argumentiem:

Var arr = jauns Array();

Šim tipam tiks izveidots tukšs masīvs, kas līdzvērtīgs LITERAL.

Vaicājuma konstruktors ar vienu skaitlisku argumentu, kas norāda vairākus masīvus:

Var arr = jauns masīvs(10);

Šobrīd tiks izveidots tukšs noteiktas dzīves masīvs. Šo masīva () konstruktora wiki formu var izmantot, lai sakārtotu tā priekšā esošā masīva atmiņu, lai atcerētos elementu skaitu. Lai izrādītu cieņu, ar šo masīvā vērtības netiek ņemtas.

Precīzi norādiet pirmo divu vai vairāku elementu vērtības masīvā vai viena elementa, kas nav skaitlisks, vērtības konstruktora wiki:

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

Tādā veidā konstruktora argumenti kļūst par jaunā masīva elementu vērtībām. Masīva literāļu izvēle ir praktiski vienkāršāka, tā ir līdzīga Array() konstruktoram.

Elementu lasīšana un rakstīšana masīvā

Piekļuve masīva elementiem ir rezervēta operatora palīdzībai. Loka ļaunums ir saistīts ar spēka klātbūtni uz masīvu. Priekšgala vidū es varu to diezgan daudz mainīt, kas man pievērš nozīmi. Šī sintakse ir nejauša gan lasīšanai, gan i elementa vērtības ierakstīšanai masīvā. Turklāt, pieņemsim, ka visiem padomiem ir sniegtas JavaScript instrukcijas:

// Izveidot masīvu ar vienu elementu var arr = [ "pasaule"]; // Lasīt elementu 0 var value = arr; // Ierakstiet vērtību elementam 1 arr = 3,14; // Ierakstiet vērtību elementam 2 i = 2; arr[i] = 3; // Ierakstiet vērtību elementam 3 arr = "sveiki"; // Lasīt elementu 0 un 2, ierakstīt vērtību elementam 3 arr] = arr;

Es domāju, ka masīvs ir specializēta objektu dažādība. Kvadrātveida arkas, piemēram, uzvarošas, lai piekļūtu masīva elementiem, darbojas tādā pašā veidā, kā kvadrātveida arkas, kā uzvaras, lai piekļūtu objektu autoritātēm. JavaScript tulks pārveido skaitļus ciparu indeksu lokos rindās - indekss 1 pārveido par rindu "1" - un pēc tam uzvarošās rindas kā autoritātes nosaukumus.

Rindās pārveidotajos skaitliskajos indeksos nav nekā īpaša: to pašu var izpētīt ar nozīmīgākajiem objektiem:

var obj = (); // Izveidot vienkāršu objektu obj = "one"; // indeksu joga ar veseliem skaitļiem

Masīvu īpatnība ir tāda, ka ar dažādiem autoritātes nosaukumiem, kas nav redzami veseli skaitļi, masīvi automātiski piešķir autoritātes vērtības. garums. Piemēram, lielāks darbu klāsts ir ar vienu elementu. Saskaitīsim elementu vērtības ar indeksiem 1, 2 un 3. Šo darbību rezultātā masīva jaudas garuma vērtība mainījās un kļuva vienāda ar 4.

Slidiniet, lai lasītu indeksus masīvā objektu iestāžu nosaukumu formā. Visi indeksi ir iestāžu nosaukumi, bet tikai iestādes, kuru nosaukumi ir apzīmēti ar veseliem skaitļiem, ir indeksi. Visi masīvi ir objekti, un tiem varat pievienot pilnvaras ar jebkādiem nosaukumiem. Taču, lai arī autoritatitāte traucē, tāpat kā masīva indeksi, masīvi reaģē uz vērtību, nepieciešamības gadījumā mainot autoritatitātes garuma vērtības.

Cieniet, ka masīvu indeksā ir atļauts uzvarēt negatīvus, nevis veselus skaitļus. Tādā veidā skaitļi tiek pārveidoti rindās, piemēram, uzvarošie, kā autoritātes vārdi.

Elementu pievienošana un noņemšana masīvam

Mēs jau esam sapratuši, ka vienkāršākais veids, kā pievienot elementus lauku masīvam, ir pievienot vērtības jauniem indeksiem. Lai masīva beigās pievienotu vienu vai vairākus elementus, varat arī uzvarēt metodi push ():

var arr=; // Izveidojiet tukšu masīvu arr.push("zero"); // Pievienot vērtību beigās arr.push ( "one", 2); // Pievienojiet vēl divas vērtības

Varat arī pievienot elementu masīva beigām, piešķirot arr elementam vērtību. Lai ievietotu elementu masīva vālītē, varat izmantot vikorista metodi unshift(), Kuri masīva galvenie elementi tiek pārvietoti uz pozīcijām ar augstākiem augstiem indeksiem.

Jūs varat redzēt masīva elementus ar dzēšanas operatora palīdzību, kas liecina par objektu spēku:

var arr=; dzēst arr; 2 in arr; // false, indekss 2 nevērtību masīvā arr.length; // 3: dzēšanas operators nemaina garuma masīva jaudu

Elementa redzamība tiek uzminēta (bet dažreiz tā tiek mainīta), piešķirot šim elementam nenoteiktu vērtību. Atcerieties, ka dzēšanas operatora nomešana uz masīva elementu nemaina jaudas garuma vērtību un nesakļauj elementus ar augstākiem augstiem indeksiem, tāpēc tas ir tukšs, jo pēdējais elements tika izdzēsts.

Turklāt ir iespējams redzēt elementus masīva beigās, vienkārši ieviešot jaunu jaudas garuma vērtību. Masivi metode pop ()(Pretēji metodei push()), kas maina iepriekšējo masīvu par 1 un pagriež dzēstā elementa vērtību. Arī metode maiņa ()(Pretēji unshift() metodei), kas ir elements, kas parādās masīva vālītē. Dzēšanas operatora skatījumā, izmantojot Shift() metodi, visi elementi tiek sakļauti pozīcijā zem to straumes indeksiem.

Nareshti іsnuє bagāta metode salaist (), kas ļauj ievietot, redzēt un aizstāt masīva elementus. Vіn zmіnyuє znachennya znachivostі garums і zrushuє elementi masīvs s vairāk zems vai vysokimi _indeksi pasaulē nebkhodnostі. Visi tsі methodi mi rasberemo trohi pіznіshe.

bagātīgi masīvi

JavaScript neatbalsta "pareizos" bagātīgos masīvus, bet ļauj tos slikti atdarināt citiem masīviem. Lai piekļūtu masīva datu elementam, izmantojiet dubultās acsināšanas operatoru.

Piemēram, pieņemsim, ka mainīgā matrica ir skaitļu masīvu masīvs. Ādas elementa matrica [x] ir skaitļu masīvs. Lai piekļūtu līdz vienam skaitlim masīvā, varat pagriezt, izmantojot matricu [x] [y]. Zemāk ir norādīts konkrēts dibens, divu pasaules masīvs uzvar reizināšanas tabulu veidā:

// Izveidot bagātāku masīvu var table = new Array (10); // Tabulā ir 10 rindas (var i = 0; i

Masīvu klases metodes

ECMAScript 3 standarts noliktavā Array.prototype nosaka bezpersoniskas funkcijas darbam ar masīviem, kas ir pieejamas kā metode jebkuram masīvam. Šīs metodes tiks parādītas gaidāmajos atjauninājumos.

join() metode

Metode Array.join() pārvērš visus masīva elementus rindās, savienojot tās un pagriežot to pašu rindu. Nesaistoša argumenta gadījumā metodei varat nodot rindu, jo jūs uzvarēsit, pievienojot rezultātam elementus pēc kārtas. Tāpat kā rindu izkliedētājs nav norādīts, koma ir uzvaroša. Piemēram, nākamais fragments rada rindu "1,2,3":

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

reverse() metode

Metode Array.reverse() maina elementu secību masīvā apgrieztā veidā un maina masīva pārkārtošanu. Permutācija tiek nejaušināta ap ārējo masīvu, lai šī metode neradītu jaunu masīvu no objektu secības, bet gan pārkārtotu tos jau esošā masīvā. Piemēram, šajā fragmentā apgrieztā () un savienojuma () metodes tiek atslābinātas, kā rezultātā tiek iegūta rinda "3,2,1":

var arr=; arr.reverse(). pievienoties (); // "3,2,1"

sort() metode

Metode Array.sort() sašķiro elementus dotajā masīvā un pagriež sakārtoto masīvu. Tā kā metodi sort() sauc bez argumentiem, tā tiek sakārtota alfabētiskā secībā (elementu sakārtošanai tie tiek mainīti rindās, kas nav nepieciešams). Nenozīmīgi elementi tiek pārnesti uz galīgo masīvu.

Lai kārtotu jebkurā citā secībā alfabētiskā secībā, metodei sort() kā argumentu var nodot vienādas secības funkciju. Šī funkcija ir iestatīta, kurš no diviem її argumentiem ir vainojams iepriekš sakārtotajā sarakstā. Tāpat kā pirmais arguments var invertēt citu, izlīdzināšanas funkcija var invertēt negatīvu skaitli. Tāpat kā pirmais arguments var sekot otram sakārtotā masīvā, funkcija var pagriezt skaitli, kas ir lielāks par nulli. Un tā kā abas vērtības ir līdzvērtīgas (tad to secības secība nav svarīga), izlīdzināšanas funkcija ir atbildīga par 0 pagriešanu:

var arr=; arr.sort(); // Alfabēta secība: 1111, 222, 33, 4 arr.sort (funkcija (a, b) (// Skaitliskā secība: 4, 33, 222, 1111 return ab; // Pagriezt vērtību 0 // atmest kārtošanas secību a un b)); // Kārtot atpakaļ, no lielākā uz mazāko arr.sort (funkcija (a, b) (atgriešanās b-a));

Atjaunot cieņu, prasmīgi uzvarēt šajā nenosauktās funkcijas fragmentā. Uzvarošas uzvaras funkcija ir tikai šeit, tāpēc nav vajadzības tai dot nosaukumu.

concate() metode

Metode Array.concat () izveido un pagriež jaunu masīvu, lai aizstātu pašreizējā masīva elementus, kuriem izsauc concat () metode, un visu concat () metodes nodoto argumentu vērtību. It kā tas būtu kaut kādi argumenti paši par sevi є masīvs, masīva pagriešanai tiek pievienoti jogas elementi. Tomēr tas nozīmē, ka nenotiek rekursīva masīva pārveidošana no masīviem vienā masīvā. Concat() metode nemaina ievades masīvu. Nolaidiet dibena šķēpu:

var arr=; arr.concat(4, 5); // pagriezt arr.concat(); // pagriezt arr.concat (,) // pagriezt arr. concat (4,]) // pagriezt]

slice() metode

Metode Array.slice() pagriež masīvam piešķirto šķēli vai apakšmasu. Divi metodes argumenti nosaka vālīti un fragmenta rotācijas beigas. Masīvs tiek pagriezts, lai aizstātu elementu, kura priekšraksta numurs ir pirmajā argumentā, plus visi nākamie elementi, līdz pat elementam (bet neietverot) tā priekšraksta numuru citā argumentā.

Tiek norādīts tikai viens arguments, kas pagriež masīvu, lai noņemtu visus elementus no ziņas pozīcijas līdz masīva beigām. It kā tas būtu kaut kāds arguments, tam var būt vērtība, tas norādīs elementa numuru, tomēr visu masīvu. Tādējādi arguments -1 dod atlikušo masīva elementu, bet arguments -3 - pēdējā masīva trešo elementu. Šķēpa dibena ass:

var arr=; arr.slice(0.3); // pagriezt arr.slice (3); // pagriezt arr. slice (1, -1); // pagriezt arr. slice (-3, -2); // pagrieziens

splice() metode

Metode Array.splice() ir vispārīga metode elementu ievietošanai vai noņemšanai no masīva. Skatoties uz šķēluma () un concat () metodes, savienojuma () metode maina ievades masīvu atbilstoši zvanu skaitam. Uzmanību, ka savienojuma () un šķēluma () metodēm jau var būt līdzīgi nosaukumi, taču tās var būt pilnīgi atšķirīgas darbības.

Splice() metode var noņemt elementus no masīva, ievietot jaunus elementus vai veikt aizskarošas darbības vienas nakts laikā. Ja nepieciešams, masīva elementi tiek pārvietoti tā, lai pēc ievietošanas vai noņemšanas tiktu izveidota nepārtraukta secība.

Pirmais splice() metodes arguments ir pozīcija masīvā atkarībā no ievietošanas un/vai dzēšanas. Vēl viens arguments parāda elementu skaitu, it kā tie būtu jānoņem (virizan) no masīva. Kā vēl viens izlaiduma arguments, visi masīva elementi ir redzami beigām piešķirtajā masīvā. Splice() metode pagriež noņemto elementu masīvu vai (it kā noņemtu elementu nebūtu) tukšu masīvu.

Pirmie divi argumenti splice() metodei piešķir skatāmos masīva elementus. Šiem argumentiem var sekot vairāki papildu argumenti, kas apzīmē elementus, kas tiks ievietoti masīvā, sākot no pirmajam argumentam piešķirtās pozīcijas.

var arr=; arr.splice(4); // pagriezt, arr = arr.splice(1,2); // pagriezt, arr = arr.splice(1,1); // pagriezties; arr=arr=; arr.splice(2,0, "a", "b"); // pagriezties; arr=

push() un pop() metodes

Push() un pop() metodes ļauj strādāt ar masīviem, kā arī ar skursteņiem. Push() metode pievieno vienu vai vairākus jaunus elementus masīva beigām un pagriež jaunu. Pop () metode veic apgrieztu darbību - noņem atlikušo masīva elementu, maina masīva aizmuguri un pagriež tā vērtību. Lai ievērotu aizskarošo metodi, lai mainītu ārējo masīvu, nevis izveidotu modificētu kopiju.

unshift() un shift() metodes

Unshift () un Shift () metodes var veikt tāpat kā push () un pop (), attaisnojot elementu ievietošanu un izņemšanu masīva vālītē, nevis beigās. Unshift () metode pārvieto svarīgus elementus uz lielākiem indeksa indeksiem, pievieno elementu vai elementu masīvam uz vālītes un pagriež jauno primāro masīvu. Shift () metode redz un pagriež pirmo masīva elementu, nobīdot visus virzošos elementus par vienu pozīciju uz leju, lai tas aizņemtu vietu, kas gāja uz masīva vālītes.