Գործարկեք վերը նշված կոդը: Պատվերը կստանաք 1, 15, 2: Դա պայմանավորված է նրանով, որ մեթոդը ամեն ինչ վերածում է տողի և օգտագործում է լեքսիկոգրաֆիական լռելյայն կարգը:

Նախորդ հոդվածում մենք խոսեցինք այն մասին, թե ինչ է դա և ինչպես աշխատել դրա հետ: Այս հոդվածում մենք կխոսենք դրա մասին բազմաչափ զանգված.

Այն զանգված է, որն ունի մեկ կամ մի քանի տարրեր, որոնք նույնպես զանգված են: Կախված գովազդի խորությունից, մասնավորապես, այն կարող է կոչվել երկչափ զանգված(2 մակարդակ) կամ եռաչափ զանգված(3 մակարդակ) կամ քառաչափ(4 մակարդակ) և այլն:

Ամենահայտնին ՝ միակողմանի զանգվածից հետո, ամենից հաճախ օգտագործվում է երկչափ զանգվածը: Մենք այն ավելի մանրամասն կուսումնասիրենք:

Ինչպես տեսնում եք, երկչափ զանգվածի տարրերը միաչափ զանգվածներ են: Եթե ​​այս միաչափ զանգվածները պարունակեին ավելի շատ զանգվածներ, ապա arr զանգվածն արդեն եռաչափ կլիներ:

Օրինակ, եկեք ստեղծենք երեք պարզ զանգված և դրանք լրացնենք տվյալներով: Առաջինը մենք կլրացնենք զույգ թվերով, երկրորդը ՝ կենտ թվերով, իսկ երրորդը ՝ որոշ կամայական տվյալներով:

// Հայտարարել երեք դատարկ զանգված var evenNumbers = new Array (); // փոփոխական k - զանգվածային ինդեքսների համար evenNumbers var k = 0; var oddNumbers = նոր զանգված (); // փոփոխական n - զանգվածային ինդեքսների համար oddNumbers var n = 0; var data = new Array («մեքենա», «ինքնաթիռ», ճշմարիտ, 89, «մ»); // Լրացրեք զանգվածը evenNumbers, զույգ թվերով (var i = 1; i

Տեսնելու համար, թե ինչ կա զանգվածի ներսում, կարող եք օգտագործել այնպիսի գործիք, ինչպիսին է մխիթարել.

Օրինակ, մենք ցանկանում ենք տեսնել կենտ թվերով կենտ թվերով կենտ թվեր: Դա անելու համար ստորև նշված ծածկագրում գրեք հետևյալ տողը.

Console.log (կենտ համարներ);

Արդյունքը տեսնելու համար հարկավոր է բացել մխիթարել դիտարկիչում... Google Chrome- ում դա արվում է այսպես. Աջ սեղմեք էջի վրա և համատեքստի ընտրացանկից ընտրեք «Դիտել կոդը» վերջին տարբերակը, այսինքն ՝ տեսուչը: Անգլերեն տարբերակում այս տարբերակը կոչվում է Inspect:

Եվ ներքևում կհայտնվի մշակողի գործիքագոտին: Դրա մեջ դուք պետք է գնաք Վահանակի ներդիր:

Այժմ, որպեսզի ստեղծել երկչափ զանգված, դուք պետք է հայտարարեք այն և դրան ավելացնեք վերևում ստեղծված մեկ ծավալային զանգվածները:

// Հայտարարեք երկչափ զանգված երկուDimens և լրացրեք այն var twoDimens = նոր զանգված (զույգ թվեր, կենտ թվեր, տվյալներ); console.log (twoDimens);

Եկեք տեսնենք այս զանգվածի բովանդակությունը վահանակում:

կրկնվում է երկչափ զանգվածի վրայով

Նախ, եկեք սովորենք ինչպես մուտք գործել երկչափ զանգվածի տարրեր.

Ինչպես առանձին զանգվածների դեպքում, այնպես էլ տարրերը հասանելի են իրենց ինդեքսներով:

Օրինակ, եկեք ցուցադրենք տարրը ինդեքսում 3 կենտ թվերով զանգվածից (կենտ թվեր): TwoDimens երկչափ զանգվածի միաչափ զանգվածի ինդեքսը մեկն է (1):

Document.write ("Տարօրինակ թվերով տարրը կենտ թվերի կենտ թվերի քանակն է." + TwoDimens); // Տարր ՝ 7

TwoDimens զանգվածում մենք վերաբերում ենք ինդեքս 1 -ի տարրին: Այս ինդեքսի տարրը տարօրինակ թվերի զանգվածն է: Եվ այս զանգվածում մենք արդեն մուտք ենք գործում 3 ինդեքս ունեցող տարր, որը 7 թիվն է:

Հիմա անցնենք բուն հարցին ինչպես կրկնել երկչափ զանգվածի վրա.

Երկկողմանի զանգվածի օղակը կատարվում է երկակի հանգույցի միջոցով: Օրինակ, եկեք կրկնվենք մեր twoDimens զանգվածի վրա:

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

Eուցանիշով տարր " + i +" " + j +"հավասար է ՝ " + երկուՉափ [i] [j] +"

Առաջին օղակում մենք կրկնում ենք բուն TwoDimens զանգվածի վրայով: Երկրորդ հանգույցում մենք արդեն կրկնում ենք հենց տարրի (զանգվածի) վրա: Նախ, i փոփոխականը հավասար է 0. Հետևաբար, երկրորդ հանգույցում մենք առաջին անգամ կրկնում ենք evenNumbers առաջին զանգվածի վրա, որն ունի 0. ինդեքս: Եվ արդեն երկրորդ հանգույցի ներսում մենք մուտք ենք գործում այս զանգվածի տարրեր: Այսպիսով ՝ twoDimens [j]: Որտեղ j տատանվում է 0 -ից մինչև զույգ թվերի զանգվածի երկարություն:

Առաջին զանգվածի տարրերի վրա կրկնելուց հետո մենք վերադառնում ենք առաջին օղակին, ավելացնում ենք i փոփոխականը և անցնում երկրորդ զանգվածի oddNumbers- ին, որն ունի ինդեքս 1. Եվ այսպես, մենք կրկնում ենք երկչափ զանգվածի յուրաքանչյուր տարրի վրա: երկչափ.

Հիմա եկեք նայենք այս որոնման արդյունքին.

Դա այն ամենն է, ինչի մասին ես ուզում էի խոսել այս հոդվածում: Այժմ դուք գիտեք, թե ինչպես ստեղծել երկչափ զանգված, ինչպես մուտք գործել երկչափ զանգվածի տարրեր և ինչպես կրկնել երկչափ զանգվածի վրա: Հուսով եմ, որ ամեն ինչ պարզ էր: Մաղթում եմ ձեզ մեծ հաջողություն:

Raանգվածներ

Զանգվածարժեքների պատվիրված հավաքածու է: Arանգվածի արժեքները կոչվում են տարրեր, և յուրաքանչյուր տարր բնութագրվում է զանգվածում թվային դիրքով, որը կոչվում է ինդեքս: Sանգվածները JavaScript- ում անտիպ են. Զանգվածի տարրերը կարող են լինել ցանկացած տիպի, իսկ նույն զանգվածի տարբեր տարրերը կարող են լինել տարբեր տեսակի: Arանգվածի տարրերը կարող են լինել նույնիսկ օբյեկտներ կամ այլ զանգվածներ, ինչը թույլ է տալիս ստեղծել տվյալների բարդ կառուցվածքներ, ինչպիսիք են օբյեկտների զանգվածները և զանգվածների զանգվածները:

Sանգվածի ինդեքսները JavaScript- ում զրոյական են և օգտագործում են 32-բիթ ամբողջ թվեր. Զանգվածի առաջին տարրն ունի ինդեքս 0. JavaScript զանգվածները դինամիկ են. Դրանք կարող են աճել և փոքրանալ ըստ անհրաժեշտության. կարիք չկա հայտարարելու զանգվածների ֆիքսված չափերը, երբ դրանք ստեղծվում են, կամ հիշողությունը վերաբաշխելու դեպքում, երբ դրանք չափափոխվում են:

Sանգվածները JavaScript- ում օբյեկտների մասնագիտացված ձև են, և զանգվածների ինդեքսները մի փոքր ավելին են նշանակում, քան պարզապես գույքի անուններ, որոնք պատահաբար ամբողջ թվեր են:

.Անգվածների ստեղծում

Anանգված ստեղծելու ամենահեշտ ձևը բառացի է, որը քառակուսի փակագծերում զանգվածային տարրերի պարզ ստորակետով ցուցակ է: Liteանգվածային բառացի արժեքները պարտադիր չէ, որ լինեն հաստատուն. Դրանք կարող են լինել ցանկացած արտահայտություններ, ներառյալ առարկայական բառացի բառերը.

Var դատարկ =; // Դատարկ զանգված var համարներ =; // rayանգված հինգ թվային տարրերով var misc = [1.1, true, "a",]; // Տարբեր տեսակների 3 տարրեր + հետևի ստորակետով var base = 1024; var աղյուսակ =; // var arrObj = [,] փոփոխականներով փոփոխականներով; // առարկաներ պարունակող 2 զանգված

Arանգվածի բառացի շարահյուսությունը թույլ է տալիս տեղադրել կամընտիր հետապնդող ստորակետ, այսինքն. literal [,] համապատասխանում է զանգվածին երկու տարրով, այլ ոչ թե երեքով:

Anանգված ստեղծելու մեկ այլ եղանակ է զանգահարել կոնստրուկտորին Զանգված ()... Կոնստրուկտորը կարելի է անվանել երեք տարբեր եղանակներով.

Callանգահարեք կոնստրուկտորին ՝ առանց փաստարկների.

Var arr = նոր զանգված ();

Այս դեպքում կստեղծվի բառացիին համարժեք դատարկ զանգված:

Callանգահարեք կոնստրուկտորին մեկ թվային փաստարկով `նշելով զանգվածի երկարությունը.

Var arr = նոր զանգված (10);

Այս դեպքում կստեղծվի նշված երկարության դատարկ զանգված: Array () կոնստրուկտոր կանչելու այս ձևը կարող է օգտագործվել զանգվածի համար հիշողություն նախապես հատկացնելու համար, եթե դրա տարրերի թիվը նախապես հայտնի է: Նկատի ունեցեք, որ սա զանգվածներ չի պահում որևէ արժեք:

Կոնստրուկտորի կանչում հստակորեն նշեք զանգվածի առաջին երկու կամ ավելի տարրերի կամ մեկ ոչ թվային տարրի արժեքները.

Var arr = նոր զանգված (5, 4, 3, 2, 1, «փորձարկում»);

Այս դեպքում կոնստրուկտորի փաստարկները դառնում են նոր զանգվածի տարրերի արժեքներ: Arանգվածային տառատեսակների օգտագործումը գրեթե միշտ ավելի հեշտ է, քան Array () կոնստրուկտորը այս կերպ օգտագործելը:

Arանգվածի տարրեր կարդալ և գրել

Arանգվածի տարրերը հասանելի են օպերատորի միջոցով: Փակագծերի ձախ մասում պետք է լինի զանգվածային հղում: Կամայական արտահայտությունը, որը վերադարձնում է ոչ բացասական ամբողջ արժեք, պետք է լինի փակագծերում: Այս շարահյուսությունը հարմար է զանգվածի տարրի արժեքը կարդալուն և գրելուն: Հետևաբար, JavaScript- ի հետևյալ բոլոր հայտարարությունները վավեր են.

// Ստեղծել զանգված մեկ տարրով var arr = ["աշխարհ"]; // Կարդալ տարրը 0 var value = arr; // Գրել արժեքը 1 տարրի arr = 3.14; // Գրեք 2 տարրի արժեքը i = 2; arr [i] = 3; // Գրել արժեք 3 տարրի arr = "բարև"; // Կարդացեք 0 -րդ և 2 -րդ կետերը, արժեքը գրեք 3 -րդ կետին arr] = arr;

Հիշեցնեմ, որ զանգվածները մասնագիտացված օբյեկտ են: Arանգվածի տարրերին մուտք գործելու համար օգտագործվող քառակուսային փակագծերը գործում են ճիշտ այնպես, ինչպես քառակուսի փակագծերը, որոնք օգտագործվում են օբյեկտի հատկություններին մուտք գործելու համար: JavaScript- ի թարգմանիչը փակագծերում թվային ինդեքսները վերածում է տողերի. Ցուցիչը 1 դառնում է «1» տող, այնուհետև տողերը օգտագործում է որպես հատկությունների անուններ:

Թվային ինդեքսները տողերի վերածելու մեջ ոչ մի հատուկ բան չկա. Նույնը կարելի է անել սովորական օբյեկտների հետ.

Var obj = (); // Ստեղծեք պարզ օբյեկտ obj = "one"; // Ինդեքսավորեք այն ամբողջ թվերով

Arանգվածների առանձնահատկությունն այն է, որ գույքի անուններ օգտագործելիս, որոնք ոչ բացասական ամբողջ թվեր են, զանգվածները ինքնաբերաբար որոշում են հատկության արժեքը երկարությունը... Օրինակ, arr զանգվածը ստեղծվել է վերևում ՝ մեկ տարրով: Այնուհետև, դրա տարրերին 1, 2 և 3 ցուցանիշներ են վերագրվում արժեքներին:

Դուք պետք է հստակ տարբերեք զանգվածի ինդեքսները և օբյեկտի հատկությունների անունները: Բոլոր ինդեքսները սեփականության անուններ են, բայց միայն ամբողջ անուններով հատկությունները ինդեքսներ են: Բոլոր զանգվածները օբյեկտներ են, և դրանց կարող եք հատկություններ ավելացնել ցանկացած անունով: Այնուամենայնիվ, եթե դուք դիպչում եք զանգվածների ինդեքս հանդիսացող հատկություններին, զանգվածները արձագանքում են ՝ ըստ անհրաժեշտության թարմացնելով երկարության հատկության արժեքը:

Նկատի ունեցեք, որ բացասական և ոչ ամբողջ թվերը թույլատրվում են որպես զանգվածների ինդեքսներ: Այս դեպքում թվերը վերածվում են տողերի, որոնք օգտագործվում են որպես հատկությունների անուններ:

Arանգվածի տարրերի ավելացում և հեռացում

Մենք արդեն տեսել ենք, որ զանգվածին տարրեր ավելացնելու ամենահեշտ ձևը նոր ինդեքսներին արժեքներ վերագրելն է: Կարող եք նաև օգտագործել մեթոդը `զանգվածի վերջում մեկ կամ մի քանի տարր ավելացնելու համար հրում ():

Var arr =; // Ստեղծեք դատարկ զանգված arr.push («զրո»); // Ավելացրեք արժեք վերջնական arr.push («մեկ», 2); // Ավելացնել ևս երկու արժեք

Դուք նաև կարող եք տարր ավելացնել զանգվածի վերջում ՝ նշանակելով arr տարրին արժեք: Anանգվածի սկզբում տարր տեղադրելու համար կարող եք օգտագործել մեթոդը չփոխել ()իսկ զանգվածի առկա տարրերը տեղափոխվում են ավելի բարձր ցուցանիշներ:

Դուք կարող եք ջնջել զանգվածի տարրեր ՝ օգտագործելով ջնջման օպերատորը, ինչպես օբյեկտների սովորական հատկությունները.

Var arr =; ջնջել arr; 2 arr; // կեղծ, զանգվածի ինդեքս 2 -ը անորոշ է arr.length; // 3: ջնջման օպերատորը չի փոխում զանգվածի երկարության հատկությունը

Տարրը հեռացնելը նման է (բայց մի փոքր այլ) այդ տարրին չսահմանված արժեք տալուն: Նկատի ունեցեք, որ ջնջման օպերատորի կիրառումը զանգվածի տարրի վրա չի փոխում երկարության հատկության արժեքը, ինչպես նաև չի շարժվում ներքև ՝ ավելի բարձր ինդեքսավորված տարրերով ՝ տարրը ջնջելուց հետո մնացած դատարկությունը լրացնելու համար:

Բացի այդ, զանգվածի վերջում հնարավոր է տարրեր հեռացնել ՝ պարզապես երկարության հատկությանը նոր արժեք տալով: Arանգվածներն ունեն մեթոդ փոփ ()(push- ի հակառակ) (), որը նվազեցնում է զանգվածի երկարությունը 1 -ով և վերադարձնում հեռացված տարրի արժեքը: Կա նաև մեթոդ հերթափոխ ()(unshift- ի հակառակը ()), որը հեռացնում է տարրը զանգվածի սկզբում: Ի տարբերություն ջնջման օպերատորի, shift () մեթոդը բոլոր տարրերը մեկ դիրքով իջեցնում է նրանց ընթացիկ ցուցանիշներից ցածր:

Ի վերջո, կա բազմաֆունկցիոնալ մեթոդ զուգավորում (), որը թույլ է տալիս տեղադրել, ջնջել և փոխարինել զանգվածների տարրեր: Այն փոխում է երկարության հատկության արժեքը և ըստ անհրաժեշտության տեղաշարժում զանգվածի տարրերը ավելի ցածր կամ ավելի բարձր ինդեքսներով: Այս բոլոր մեթոդները մենք կքննարկենք մի փոքր ուշ:

Բազմաչափ զանգվածներ

JavaScript- ը չի աջակցում «իրական» բազմաչափ զանգվածներին, բայց լավ է կատարում նրանց նմանակումը `օգտագործելով զանգվածներից զանգվածները: Arանգվածների զանգվածում տվյալների տարր մուտք գործելու համար բավական է երկու անգամ օգտագործել օպերատորը:

Օրինակ, ենթադրենք, որ փոփոխական մատրիցան թվերի զանգվածների զանգված է: [X] մատրիցայի յուրաքանչյուր տարր թվերի զանգված է: Դուք կարող եք օգտագործել մատրիցա [x] [y] արտահայտությունը զանգվածի որոշակի թվին մուտք գործելու համար: Ստորև բերված է կոնկրետ օրինակ, որտեղ երկչափ զանգվածը օգտագործվում է որպես բազմապատկման աղյուսակ.

// Ստեղծել բազմաչափ զանգված var սեղան = նոր զանգված (10); // Աղյուսակում կա 10 տող (var i = 0; i

Rayանգվածի դասի մեթոդներ

ECMAScript 3 ստանդարտը սահմանում է Array.prototype- ի կազմում զանգվածների հետ աշխատելու շատ հարմար գործառույթներ, որոնք հասանելի են որպես ցանկացած զանգվածի մեթոդներ: Այս մեթոդները կներկայացվեն հետևյալ ենթաբաժիններում:

Join () մեթոդը

Array.join () մեթոդը զանգվածի բոլոր տարրերը փոխակերպում է տողերի, դրանք միացնում և վերադարձնում ստացված տողը: Ընտրովի փաստարկը կարող է փոխանցվել մեթոդին տողով, որը կօգտագործվի արդյունքի տողի տարրերը առանձնացնելու համար: Եթե ​​սահմանազատող տող նշված չէ, օգտագործվում է ստորակետ: Օրինակ, հետևյալ հատվածը հանգեցնում է «1,2,3» տողի:

Var arr =; arr. միանալ (); // "1,2,3" arr.join ("-"); // «1-2-3»

Հակառակ () մեթոդը

Array.reverse () մեթոդը հակադարձում է զանգվածի տարրերի կարգը և վերադարձնում վերադասավորված զանգված: Փոխանակումը կատարվում է անմիջապես սկզբնական զանգվածի վրա, այսինքն. այս մեթոդը չի ստեղծում նոր զանգված `վերադասավորված տարրերով, այլ դրանք վերադասավորում է արդեն գոյություն ունեցող զանգվածում: Օրինակ, հետևյալ հատվածը, որն օգտագործում է reverse () և join () մեթոդները, հանգեցնում է «3,2,1» տողի:

Var arr =; arr.reverse (). միանալ (); // "3,2,1"

Տեսակավորել () մեթոդը

Array.sort () մեթոդը դասավորում է սկզբնական զանգվածի տարրերը և վերադարձնում դասավորված զանգվածը: Եթե ​​տեսակավորման () մեթոդը կանչվում է առանց արգումենտների, դասավորությունը կատարվում է այբբենական կարգով (համեմատության համար, անհրաժեշտության դեպքում տարրերը ժամանակավորապես փոխակերպվում են տողերի): Չսահմանված տարրերը փաթաթված են զանգվածի վերջում:

Դուք կարող եք համեմատության գործառույթ փոխանցել որպես փաստարկ ՝ տեսակավորելու () տեսակավորելու համար ՝ ցանկացած այլ ոչ այբբենական կարգով: Այս գործառույթը սահմանում է, թե իր երկու փաստարկներից որն է դասավորված ցանկում առաջինը: Եթե ​​առաջին փաստարկը պետք է նախորդի երկրորդին, ապա համեմատության գործառույթը պետք է վերադարձնի բացասական թիվ: Եթե ​​առաջին փաստարկը պետք է հաջորդի երկրորդը դասավորված զանգվածում, ապա գործառույթը պետք է վերադարձնի զրոից մեծ թիվ: Եվ եթե երկու արժեքները համարժեք են (այսինքն ՝ դրանց կարգը կարևոր չէ), համեմատության գործառույթը պետք է վերադարձնի 0:

Var arr =; arr.sort (); // Այբբենական կարգ. կարգը a և b)); // Տեսակավորել հետընթաց, ամենաբարձրից մինչև ամենացածրը: դասակարգում (գործառույթ (ա, բ) (վերադարձ բ-ա));

Ուշադրություն դարձրեք, թե որքան հարմար է այս հատվածում օգտագործել անանուն գործառույթ: Համեմատության գործառույթը օգտագործվում է միայն այստեղ, այնպես որ կարիք չկա դրան տալ անուն:

Կոնկատի () մեթոդը

Array.concat () մեթոդը ստեղծում և վերադարձնում է նոր զանգված, որը պարունակում է սկզբնական զանգվածի տարրերը, որոնց վրա կոչվել է concat () մեթոդը և ցանկացած արգումենտի արժեքներ, որոնք փոխանցվել են concat () մեթոդին: Եթե ​​այս փաստարկներից որևէ մեկն ինքնին զանգված է, ապա դրա տարրերը ավելացվում են վերադարձված զանգվածին: Այնուամենայնիվ, պետք է նշել, որ չկա զանգվածի ռեկուրսիվ փոխակերպում զանգվածներից զանգվածների մեկ ծավալային զանգվածի: Concat () մեթոդը չի փոփոխում սկզբնական զանգվածը: Ստորև բերված են մի քանի օրինակներ.

Var arr =; arr.concat (4, 5); // Վերադարձնում է arr.concat (); // Վերադարձնում է arr.concat (,) // Վերադառնում է arr.concat (4,]) // Վերադառնում]

Slice () մեթոդը

Array.slice () մեթոդը վերադարձնում է նշված զանգվածի շերտը կամ ենթադասը: Մեթոդի երկու փաստարկները սահմանում են վերադարձված կտորի սկիզբը և վերջը: Վերադարձված զանգվածը պարունակում է առաջին արգումենտում համարակալված տարրը գումարած բոլոր հաջորդ տարրերը ՝ մինչև (բայց չներառելով) երկրորդ արգումենտում համարակալված տարրը:

Եթե ​​նշված է միայն մեկ արգումենտ, վերադարձված զանգվածը պարունակում է բոլոր տարրերը սկզբնական դիրքից մինչև զանգվածի վերջ: Եթե ​​արգումենտներից որևէ մեկը բացասական է, այն սահմանում է տարրի համարը զանգվածի վերջի համեմատ: Այսպիսով, փաստարկ -1 -ը համապատասխանում է զանգվածի վերջին տարրին, իսկ -3 փաստարկը `վերջից զանգվածի երրորդ տարրին: Ահա մի քանի օրինակ.

Var arr =; arr.slic (0.3); // Վերադարձնում է arr.slice (3); // Վերադարձնում է arr.slice (1, -1); // Վերադարձնում է arr.slice (-3, -2); // Կվերադառնա

Splice () մեթոդը

Array.splice () մեթոդը ընդհանուր մեթոդ է, որը տեղադրում կամ հեռացնում է տարրերը զանգվածից: Ի տարբերություն slice () և concat () մեթոդների, splice () մեթոդը փոփոխում է սկզբնական զանգվածը, որի վրա այն կոչվում էր: Նշենք, որ splice () և slice () մեթոդները շատ նման անուններ ունեն, բայց կատարում են բոլորովին այլ գործողություններ:

Splice () մեթոդը կարող է հեռացնել տարրերը զանգվածից, տեղադրել նոր տարրեր կամ կատարել երկուսն էլ միաժամանակ: Theանգվածի տարրերը տեղաշարժվում են ըստ անհրաժեշտության, որպեսզի տեղադրումից կամ ջնջումից հետո ձևավորվի հարակից հաջորդականություն:

Splice () մեթոդի առաջին արգումենտը սահմանում է զանգվածի դիրքը, որից պետք է տեղադրվի և / կամ ջնջվի: Երկրորդ արգումենտը սահմանում է զանգվածից հանվող (կտրված) տարրերի քանակը: Եթե ​​երկրորդ արգումենտը բաց թողնված է, ապա զանգվածի բոլոր տարրերը նշված զանգվածից մինչև զանգվածի վերջը հանվում են: Splice () մեթոդը վերադարձնում է հեռացված տարրերի զանգվածը, կամ (եթե տարրերից ոչ մեկը չի հեռացվել) դատարկ զանգված:

Splice () մեթոդի առաջին երկու արգումենտները նշում են զանգվածի տարրերը, որոնք պետք է հեռացվեն: Այս փաստարկներին կարող են հաջորդել ցանկացած այլ լրացուցիչ փաստարկներ, որոնք սահմանում են զանգվածի մեջ մտնելու տարրերը `սկսած առաջին արգումենտում նշված դիրքից:

Var arr =; arr.splice (4); // Վերադարձնում է arr = arr.splice (1,2); // Վերադարձնում է arr = arr.splice (1,1); // Կվերադառնա; arr = arr =; arr.splice (2,0, «ա», «բ»); // Կվերադառնա; arr =

Push () և pop () մեթոդները

Push () և pop () մեթոդները թույլ են տալիս աշխատել զանգվածների հետ, ինչպիսիք են կույտերը: Push () մեթոդը զանգվածի վերջում ավելացնում է մեկ կամ մի քանի նոր տարր և վերադարձնում դրա նոր երկարությունը: Pop () մեթոդը կատարում է հակառակ գործողությունը. Այն հեռացնում է զանգվածի վերջին տարրը, նվազեցնում զանգվածի երկարությունը և վերադարձնում հեռացված արժեքը: Նկատի ունեցեք, որ այս երկու մեթոդներն էլ փոխում են սկզբնական զանգվածը, այլ ոչ թե ստեղծում դրա փոփոխված պատճենը:

Unshift () և shift () մեթոդներ

Unshift () և shift () մեթոդները նույն կերպ են վարվում, ինչ push () և pop () տարբերակները, բացառությամբ, որ դրանք տեղադրում և հեռացնում են տարրերը զանգվածի սկզբում, այլ ոչ թե վերջում: Unshift () մեթոդը գոյություն ունեցող տարրերը տեղափոխում է ավելի մեծ ինդեքսներ `տեղ ազատելու համար, տարրը կամ տարրերը ավելացնում է զանգվածի սկզբում և վերադարձնում զանգվածի նոր երկարությունը: Shift () մեթոդը հեռացնում և վերադարձնում է զանգվածի առաջին տարրը ՝ բոլոր հաջորդ տարրերը տեղափոխելով մեկ դիրքով ներքև ՝ զբաղեցնելով զանգվածի սկզբում ազատված տարածքը:

Վերջին թարմացումը `09.04.2018

Raանգվածները նախատեսված են տվյալների հավաքածուների հետ աշխատելու համար: Նոր զանգված () արտահայտությունը օգտագործվում է զանգված ստեղծելու համար.

Var myArray = նոր զանգված ();

Կա նաև զանգված ստեղծելու ավելի կարճ եղանակ.

Var myArray =;

Այս դեպքում մենք ստեղծում ենք դատարկ զանգված: Բայց դուք կարող եք դրան ավելացնել նաև նախնական տվյալներ.

Var մարդիկ = [«Թոմ», «Ալիս», «Սեմ»]; console.log (մարդիկ);

Այս դեպքում myArray- ում երեք տարր կլինի: Գրաֆիկորեն այն կարող է ներկայացվել հետևյալ կերպ.

Ինդեքսներն օգտագործվում են զանգվածի առանձին տարրերին վերաբերելու համար: Հաշվարկը սկսվում է զրոյից, այսինքն ՝ առաջին տարրը կունենա 0 ինդեքս, իսկ վերջինը ՝ 2:

Var մարդիկ = [«Թոմ», «Ալիս», «Սեմ»]; console.log (մարդիկ); // Tom var person3 = մարդիկ; // Sam console.log (person3); // Սեմ

Եթե ​​մենք փորձում ենք տարր մուտք գործել զանգվածի չափից ավելի մեծ ինդեքսով, մենք անորոշ ենք դառնում.

Var մարդիկ = [«Թոմ», «Ալիս», «Սեմ»]; console.log (մարդիկ); // չսահմանված

Բացի այդ, ինդեքսի միջոցով զանգվածի տարրերի արժեքները սահմանվում են.

Var մարդիկ = [«Թոմ», «Ալիս», «Սեմ»]; console.log (մարդիկ); // Թոմ մարդիկ = "Բոբ"; console.log (մարդիկ); // Բոբ

Ավելին, ի տարբերություն այլ լեզուների, ինչպիսիք են C # կամ Java- ն, կարող եք տեղադրել տարր, որն ի սկզբանե տեղադրված չէր.

Var մարդիկ = [«Թոմ», «Ալիս», «Սեմ»]; console.log (մարդիկ); // անորոշ - զանգվածի մարդկանց մեջ ընդամենը երեք տարր կա = "Bob"; console.log (մարդիկ); // Բոբ

Հարկ է նաև նշել, որ ի տարբերություն JavaScript- ի մի շարք ծրագրավորման լեզուների, զանգվածները խիստ մուտքագրված չեն, մեկ զանգվածը կարող է պահել տարբեր տեսակի տվյալներ.

Var օբյեկտներ = ["Tom", 12, true, 3.14, false]; console.log (օբյեկտներ);

տարածման օպերատոր

Տարածման օպերատորը ... թույլ է տալիս առանձին զանգվածներ վերցնել զանգվածից.

Թող թվեր =; console.log (... թվեր); // 1 2 3 4 console.log (թվեր); //

Տարածման օպերատորը նշվում է զանգվածից առաջ: Արդյունքում ... թվեր արտահայտությունը կվերադարձնի թվերի շարք, բայց դա չի լինի զանգված, այլ առանձին արժեքներ:

Բազմաչափ զանգվածներ

Arանգվածները կարող են լինել միակողմանի և բազմաչափ: Բազմաչափ զանգվածի յուրաքանչյուր տարր կարող է լինել առանձին զանգված: Վերևում մենք դիտեցինք միաչափ զանգված, այժմ եկեք ստեղծենք բազմաչափ զանգված.

Var համարներ 1 =; // մեկ ծավալային զանգված var համարներ 2 = [,]; // երկչափ զանգված

Տեսողականորեն, երկու զանգվածները կարող են ներկայացվել հետևյալ կերպ.

Միաչափ զանգվածի համարներ 1

Anանգվածի մեկ տարր ստանալու համար օգտագործվում է նաև ինդեքս.

Var tomInfo = մարդիկ;

Միայն հիմա tomInfo փոփոխականը կներկայացնի զանգված: Ներդրված զանգվածի մեջ տարր ստանալու համար մենք պետք է օգտագործենք դրա երկրորդ հարթությունը.

Console.log ("Անուն." + Մարդիկ); // Tom console.log («Տարիքը.» + Մարդիկ); // 25

Այսինքն, եթե մենք կարող ենք տեսողականորեն ներկայացնել երկչափ զանգվածը սեղանի տեսքով, ապա մարդկանց տարրը կանդրադառնա սեղանի բջիջին, որը գտնվում է առաջին տողի և երկրորդ սյունակի խաչմերուկում (առաջին հարթությունը 0 - տող, երկրորդ հարթությունը `1 - սյունակ):

Մենք կարող ենք կատարել նաև առաջադրանքը.

Var մարդիկ = [["Tom", 25, false), ["Bill", 38, true], ["Alice", 21, false]]; մարդ = 56; // առանձին արժեք նշանակել console.log (մարդիկ); // 56 մարդ = ["Bob", 29, կեղծ]; // նշանակել զանգվածային մխիթարիչ. օրագիր (մարդիկ); // Բոբ

Բազմաչափ զանգվածներ ստեղծելիս մենք չենք սահմանափակվում միայն երկչափերով, բայց կարող ենք նաև օգտագործել լայնածավալ զանգվածներ.

Var համարներ =; թվեր =; // այժմ թվերը երկչափ զանգված են =; // այժմ թվերը եռաչափ զանգված են = 5; // 3D զանգվածի առաջին տարրը 5 console.log (համարներ) է;

Ողջույն բոլորին, ովքեր հետաքրքրված են JavaScript բազմաչափ զանգվածներով և տեսակավորմամբ: Ներկայիս հրապարակումում ես կփորձեմ լուսաբանել այս թեման բոլոր մանրամասներով:

Հետևաբար, այս հոդվածը կարդալուց հետո դուք կիմանաք, թե ինչու են բազմաչափ զանգվածները օգտագործվում վեբ ծրագրերում, ինչպես են դրանք ստեղծվում և ինչպես կարող են դրանք շահարկվել և տեսակավորվել: Եկեք սկսենք սովորել:

Ինչպե՞ս են ստեղծվում բազմաչափ զանգվածները և ինչի՞ համար են դրանք:

Սկզբից, արժե հիշել, թե ինչպես է ստեղծվում կանոնավոր միաչափ զանգված:

var զանգված =

Այժմ, հիշեք, որ բազմաչափ զանգվածը զանգվածների զանգված է:Համաձայն եմ, հնչում է տավտոլոգիա: Այնուամենայնիվ, նորից կարդացեք սահմանումը: Իրոք, բազմաչափ զանգվածը բաղկացած է որոշակի թվով բնադրվածներից:

Հաշվի առեք հետևյալ իրավիճակը. Խաղի սկզբում օգտագործողը մուտքագրում է իր անունը, իսկ ավարտից հետո էկրանին ցուցադրվում է խաղացողների անունների և նրանց գրառումների գնահատման աղյուսակը:

Հասկանալի է, որ նման տեղեկատվությունը պահվում է տվյալների բազայում: Բայց երբ այն հանում ենք տվյալների բազայից, ստանում ենք բազմաչափ զանգված: Ի վերջո, յուրաքանչյուր ենթաշերտ պարունակում է խաղացողի մուտքը և վաստակած միավորների քանակը:

Ամեն ինչ այսպիսի տեսք կունենա.

var արդյունքներ = [["Markus", 333], ["Natasha", 211], ["Alexey", 124]];

Ինչպես տեսնում եք, տեղեկատվությունը կարող է պահվել տարասեռ: Այն կարող է լինել տողեր, թվեր և նույնիսկ: Դա հնարավոր է, քանի որ ներսում գտնվող զանգվածները անտիպ են:

Այս դեպքում տարրերի հասանելիությունը տեղի է ունենում կրկնակի օպերատորի միջոցով:

Նյութը համախմբելու համար վերլուծեք փոքր ծրագիր:

Արդյունքներ =

Raանգվածները բավականին հարմար միջոց են պատվիրված բարդ տվյալների պահպանման համար `դրանք մշակելիս: Բացի այդ, նրանց հետ աշխատելը շատ հարմար է, և, միևնույն ժամանակ, դրանց մշակման արագությունը բավականին բարձր է:

Տվյալների տեսակավորման մեթոդներ

JavaScript- ի զանգվածների համար կա ներկառուցված մեթոդ, որը կոչվում է տեսակավորել ()... Այս գործիքը շատ ճկուն է: Եվ հիմա ես կբացատրեմ, թե ինչու:

Եթե ​​դուք օգտագործում եք մեթոդ ՝ առանց պարամետրերի, ապա այն ինքնաբերաբար կարգավորում է ենթաշերտերը ըստ առաջին տարրի այբբենական կարգով: Այսպիսով, զանգահարելիս արդյունքները:տեսակավորել ()վերլուծված օբյեկտն այսպիսի տեսք կունենա.

Ալեքսեյ, 124

Մարկուս, 333

Նատաշա, 211

Եվ եթե փոխանակեք տարրերը յուրաքանչյուր ներկառուցված զանգվածում, կստանաք.

124, Ալեքսեյ

211, Նատաշա

333, Մարկուս

Այս դեպքում, համեմատության համար, բոլոր տարրերը ժամանակավորապես վերածվում են տողերի:

Եթե ​​կոնկրետ առաջադրանք լուծելու համար ձեզ անհրաժեշտ է տարրեր ոչ ստանդարտ եղանակով տեսակավորող գործառույթ, ապա կարող եք ինքներդ գրել և փոխանցել այն որպես պարամետր տեսակավորել ()... Պետք է հաշվի առնել, որ սովորական գործառույթը պետք է վերադարձնի.

• դրական թիվ (սովորաբար ընտրեք 1), եթե առաջին նշված կետը հաջորդի համեմատության երկրորդին.
• բացասական թիվ (սովորաբար -1), եթե երկրորդ ընտրված տարրը պետք է հաջորդի առաջինին.
• զրո, եթե երկու ստուգված արժեքները հավասար են:

Որպես օրինակ, վերցնենք սկզբնական զանգվածը արդյունքներըտեսակավորել ըստ կետերի: Ավելին, արդյունքները կտեսակավորվեն ամենաբարձրից մինչև ամենացածրը: Դա կարելի է անել երկու եղանակով.

Առաջին տարբերակում ես փոխեցի տեսակավորման տրամաբանությունը, այսինքն. այն իրավիճակում, երբ անհրաժեշտ է դրական թիվ վերադարձնել, ես բացասական եմ վերադարձնում և հակառակը:

Գրանցման աղյուսակ.

Բայց երկրորդ մեթոդով ես դասակարգման տրամաբանությունը թողեցի անձեռնմխելի, բայց լրացուցիչ օգտագործեցի մեկ այլ մեթոդ ` հակադարձ ()... Ինչպես ցույց է տալիս անունը, հակադարձումը հակադարձում է տարրերի կարգը:

Հետևաբար, տեսակավորման () գործառույթը այսպիսին կլինի.

գործառույթը RecordSort (a, b) (եթե (a> b) վերադարձնել 1; հակառակ դեպքում, եթե (a< b) return -1; else return 0; }

Դրանից հետո եկեք ավելացնենք վերը նշված մեթոդը:

Եզրակացությունը կատարվում է նույն ձևով:

Ուզում եմ ձեր ուշադրությունը հրավիրել մեկ կարևոր կետի վրա. Այս գործառույթներն օգտագործելիս բոլոր փոփոխությունները տեղի են ունենում այն ​​զանգվածում, որին դրանք կիրառում եք: Այսպիսով, եթե ձեզ անհրաժեշտ է պահպանել տվյալների սկզբնական ձևը, ապա ստեղծեք պատճենը, այնուհետև խմբագրեք այն:

Դե, այնպես որ, ես խոսեցի բազմաչափ զանգվածների և դրանց տեսակավորման մասին: Եթե ​​ձեզ դուր եկավ հոդվածը, ապա բաժանորդագրվեք բլոգին և կարդացեք այլ հավասարապես հետաքրքիր հրապարակումներ: Շնորհակալ կլինեմ վերահրապարակների համար: Մինչև հաջորդ անգամ!

Ցտեսություն!

Հարգանքներով ՝ Ռոման Չուեշով