გაუშვით ზემოთ კოდი. თქვენ მიიღებთ შეკვეთას 1, 15, 2. ეს იმიტომ ხდება, რომ მეთოდი ყველაფერს გარდაქმნის სტრიქონად და იყენებს ნაგულისხმევ ლექსიკოგრაფიულ რიგს.

წინა სტატიაში ჩვენ ვისაუბრეთ იმაზე, თუ რა არის ეს და როგორ უნდა ვიმუშაოთ მასთან. ამ სტატიაში ჩვენ ვისაუბრებთ მრავალგანზომილებიანი მასივი.

ეს არის მასივი, რომელსაც აქვს ერთი ან მეტი ელემენტი, რომლებიც ასევე მასივებია. რეკლამის სიღრმიდან გამომდინარე, კერძოდ, მას შეიძლება ეწოდოს ორგანზომილებიანი მასივი(2 დონე) ან სამგანზომილებიანი მასივი(3 დონე) ან ოთხგანზომილებიანი(4 დონე) და ასე შემდეგ.

ყველაზე პოპულარული, ერთგანზომილებიანი მასივის შემდეგ, რომელიც ყველაზე ხშირად გამოიყენება არის ორგანზომილებიანი მასივი. ჩვენ უფრო დეტალურად შევისწავლით მას.

როგორც ხედავთ, ორგანზომილებიანი მასივის ელემენტები არის ერთგანზომილებიანი მასივები. თუ ეს ერთგანზომილებიანი მასივები შეიცავდა მეტ მასივს, მაშინ ისრის მასივი უკვე სამგანზომილებიანი იქნებოდა.

მაგალითისთვის, შევქმნათ სამი მარტივი მასივი და შეავსოთ ისინი მონაცემებით. ჩვენ პირველს შევავსებთ ლუწი რიცხვებით, მეორეს კენტი რიცხვებით და მესამეს რაღაც თვითნებური მონაცემებით.

// გამოაცხადე სამი ცარიელი მასივი var evenNumbers = new Array (); // ცვლადი k - მასივის ინდექსებისთვის evenNumbers var k = 0; var oddNumbers = ახალი მასივი (); // ცვლადი n - მასივის ინდექსებისთვის oddNumbers var n = 0; var data = new Array ("მანქანა", "თვითმფრინავი", ჭეშმარიტი, 89, "მ"); // შეავსეთ მასივი evenNumbers, ლუწი რიცხვებით for (var i = 1; i

იმისათვის, რომ ნახოთ რა არის მასივის შიგნით, შეგიძლიათ გამოიყენოთ ისეთი ინსტრუმენტი, როგორიცაა კონსოლი.

მაგალითად, ჩვენ გვინდა ვნახოთ მასივის შინაარსი კენტი რიცხვებით oddNumbers. ამისათვის ჩაწერეთ შემდეგი ხაზი ქვემოთ მოცემულ კოდში:

Console.log (უცნაური ნომრები);

შედეგის სანახავად, თქვენ უნდა გახსნათ კონსოლი ბრაუზერში... Google Chrome– ში ეს კეთდება ასე: დააწკაპუნეთ მარჯვენა ღილაკით გვერდზე და კონტექსტური მენიუდან აირჩიეთ ბოლო ვარიანტი „კოდის ნახვა“, ანუ ინსპექტორი. ინგლისურ ვერსიაში ამ ვარიანტს ჰქვია ინსპექტირება.

ქვემოთ კი დეველოპერის ინსტრუმენტთა პანელი გამოჩნდება. მასში თქვენ უნდა გადახვიდეთ კონსოლის ჩანართზე.

ახლა იმისათვის, რომ შექმენით ორგანზომილებიანი მასივი, თქვენ უნდა გამოაცხადოთ იგი და დაამატოთ ერთგანზომილებიანი მასივები, რომლებიც თქვენ ზემოთ შექმენით.

// გამოაცხადეთ ორგანზომილებიანი მასივი twoDimens და შეავსეთ იგი var twoDimens = ახალი მასივი (ლუწი რიცხვები, უცნაური რიცხვები, მონაცემები); console.log (twoDimens);

მოდით ვნახოთ ამ მასივის შინაარსი კონსოლში.

გამეორება ორგანზომილებიან მასივზე

ჯერ ვისწავლოთ როგორ მივიღოთ ორგანზომილებიანი მასივის ელემენტები.

როგორც ერთჯერადი მასივების შემთხვევაში, ელემენტებზე წვდომა ხდება მათი ინდექსებით.

მაგალითად, მოდით გამოვყოთ ელემენტი ინდექსში 3 მასივიდან კენტი რიცხვებით (უცნაური რიცხვები). ორგანზომილებიანი მასივის უცნაური რიცხვების ინდექსი ორგანზომილებიანი მასივის twoDimens არის ერთი (1).

Document.write ("ელემენტი ინდექსი 3 უცნაური რიცხვების მასივიდან უცნაური ნომრებია:" + 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("

ელემენტი ინდექსით " + i +" " + j +"უდრის: " + ორი განზომილება [i] [j] +"

პირველ მარყუჟში, ჩვენ ვიმეორებთ ორი დიამეტრის მასივზე. მეორე მარყუჟში, ჩვენ უკვე ვიმეორებთ ელემენტზე (მასივი). პირველი, ცვლადი i უდრის 0. ამიტომ, მეორე მარყუჟში, ჩვენ პირველად ვიმეორებთ პირველ მასივში evenNumbers, რომელსაც აქვს ინდექსი 0. და უკვე მეორე მარყუჟის შიგნით, ჩვენ შევეხებით ამ მასივის ელემენტებს. ამრიგად: twoDimens [j]. სადაც j მერყეობს 0 -დან ლუწი რიცხვის მასივის სიგრძემდე.

პირველი მასივიდან ელემენტების გამეორების შემდეგ, ჩვენ ვუბრუნდებით პირველ მარყუჟს, ვამატებთ ცვლადს i და ვიმეორებთ მეორე მასივში უცნაური ნომრები, რომელსაც აქვს ინდექსი 1. და ასე ვიმეორებთ ორგანზომილებიანი მასივის თითოეულ ელემენტზე ორი განზომილება.

ახლა მოდით შევხედოთ ამ ძიების შედეგს:

სულ ეს არის რისი თქმაც მინდოდა ამ სტატიაში. ახლა თქვენ იცით, როგორ შექმნათ ორგანზომილებიანი მასივი, როგორ მიხვიდეთ ორგანზომილებიანი მასივის ელემენტებზე და როგორ გაიმეოროთ ორგანზომილებიანი მასივის საშუალებით. იმედი მაქვს ყველაფერი გასაგები იყო. გისურვებ დიდ წარმატებებს!

მასივები

მასივიარის ღირებულებების მოწესრიგებული კოლექცია. მასივის ღირებულებებს ეწოდება ელემენტები და თითოეულ ელემენტს ახასიათებს რიცხვითი პოზიცია მასივში, რომელსაც ეწოდება ინდექსი. მასივები JavaScript– ში დაუწერელია: მასივის ელემენტები შეიძლება იყოს ნებისმიერი ტიპის, ხოლო ერთი და იგივე მასივის სხვადასხვა ელემენტები შეიძლება იყოს სხვადასხვა ტიპის. მასივის ელემენტები შეიძლება იყოს ობიექტები ან სხვა მასივები, რაც საშუალებას გაძლევთ შექმნათ მონაცემთა რთული სტრუქტურები, როგორიცაა ობიექტების მასივები და მასივების მასივები.

მასივის ინდექსები JavaScript– ში არის ნულოვანი და იყენებს 32 ბიტიან რიცხვებს-მასივის პირველ ელემენტს აქვს ინდექსი 0. JavaScript მასივები დინამიურია: ისინი შეიძლება გაიზარდოს და შემცირდეს საჭიროებისამებრ; არ არის საჭირო მასივების ფიქსირებული ზომის გამოცხადება მათი შექმნისას ან მეხსიერების ხელახალი განაწილება მათი ზომის შეცვლისას.

მასივები JavaScript– ში არის ობიექტების სპეციალიზებული ფორმა, ხოლო მასივის ინდექსები ნიშნავს მეტს, ვიდრე უბრალოდ ქონების სახელებს, რომლებიც შემთხვევით რიცხვებია.

მასივების შექმნა

მასივის შესაქმნელად უმარტივესი გზაა ლიტერატურა, რომელიც არის კვადრატულ ფრჩხილებში მასივის ელემენტების მარტივი მძიმით გამოყოფილი სია. მასივის ლიტერატურული მნიშვნელობები არ უნდა იყოს მუდმივი - ისინი შეიძლება იყოს ნებისმიერი გამონათქვამი, მათ შორის ობიექტის პირდაპირი სიტყვა:

ვარ ცარიელი =; // ცარიელი მასივის var რიცხვები =; // მასივი ხუთი რიცხვითი ელემენტით var misc = [1.1, true, "a",]; // სხვადასხვა ტიპის 3 ელემენტი + დამძიმებული მძიმით var base = 1024; var მაგიდა =; // მასივი ცვლადებით var arrObj = [,]; // 2 მასივი, რომელიც შეიცავს ობიექტებს

მასივის ლიტერატურული სინტაქსი საშუალებას გაძლევთ ჩაწეროთ არასასურველი მძიმით, ე.ი. ლიტერატურული [,] ემთხვევა მასივს ორი ელემენტით და არა სამით.

მასივის შექმნის კიდევ ერთი გზაა კონსტრუქტორის გამოძახება მასივი ()... კონსტრუქტორს შეიძლება ვუწოდოთ სამი სხვადასხვა გზით:

დაურეკეთ კონსტრუქტორს არგუმენტების გარეშე:

Var arr = ახალი მასივი ();

ამ შემთხვევაში, შეიქმნება პირდაპირი მნიშვნელობის ექვივალენტის ცარიელი მასივი.

დაურეკეთ კონსტრუქტორს ერთი რიცხვითი არგუმენტით, რომელიც განსაზღვრავს მასივის სიგრძეს:

Var arr = ახალი მასივი (10);

ამ შემთხვევაში, შეიქმნება მითითებული სიგრძის ცარიელი მასივი. მასივის () კონსტრუქტორის გამოძახების ეს ფორმა შეიძლება გამოყენებულ იქნას მასივისთვის მეხსიერების წინასწარ გამოყოფისათვის, თუ მისი ელემენტების რაოდენობა წინასწარ ცნობილია. გაითვალისწინეთ, რომ ეს არ ინახავს რაიმე მნიშვნელობას მასივში.

კონსტრუქტორის ზარში გარკვევით მიუთითეთ პირველი ორი ან მეტი მასივის ელემენტის ან ერთი არა რიცხვითი ელემენტის მნიშვნელობები:

Var arr = ახალი მასივი (5, 4, 3, 2, 1, "ტესტი");

ამ შემთხვევაში, კონსტრუქტორის არგუმენტები ხდება ახალი მასივის ელემენტების ღირებულებები. მასივის ლიტერატურის გამოყენება თითქმის ყოველთვის უფრო ადვილია, ვიდრე მასივის () კონსტრუქტორის ამ გზით გამოყენება.

მასივის ელემენტების კითხვა და წერა

მასივის ელემენტებზე წვდომა ხდება ოპერატორის გამოყენებით. უნდა იყოს მასივის მითითება ფრჩხილის მარცხნივ. თვითნებური გამოთქმა, რომელიც ბრუნებს არა-უარყოფით რიცხვს, უნდა იყოს ფრჩხილებში. ეს სინტაქსი შესაფერისია მასივის ელემენტის მნიშვნელობის კითხვისა და წერისთვის. ამრიგად, ყველა შემდეგი JavaScript განცხადება მოქმედებს:

// მასივის შექმნა ერთი ელემენტით var arr = ["სამყარო"]; // წაიკითხეთ პუნქტი 0 var მნიშვნელობა = arr; // ჩაწერეთ მნიშვნელობა 1 ელემენტზე arr = 3.14; // ელემენტის მნიშვნელობის ჩაწერა 2 i = 2; arr [i] = 3; // ჩაწერეთ მნიშვნელობა 3 ელემენტზე arr = "გამარჯობა"; // წაიკითხეთ 0 და 2 პუნქტები, ჩაწერეთ მნიშვნელობა პუნქტში 3 arr = = arr;

შეგახსენებთ, რომ მასივები არის სპეციალიზებული სახის ობიექტი. მასივის ელემენტებზე წვდომისათვის გამოყენებული კვადრატული ფრჩხილები ზუსტად ისევე მოქმედებენ, როგორც კვადრატული ფრჩხილები, რომლებიც გამოიყენება ობიექტის თვისებებზე წვდომისათვის. JavaScript თარჯიმანი გარდაქმნის ფრჩხილებში არსებულ რიცხვით ინდექსებს სტრიქონებად - ინდექსი 1 ხდება სტრიქონი "1" - და შემდეგ იყენებს სტრიქონებს, როგორც თვისების სახელებს.

არაფერია განსაკუთრებული რიცხვითი ინდექსების სტრიქონად გადაქცევაში: იგივე შეიძლება გაკეთდეს რეგულარული ობიექტებით:

Var obj = (); // მარტივი ობიექტის შექმნა obj = "ერთი"; // ინდექსირება მთელი რიცხვებით

მასივების თავისებურება ის არის, რომ თვისებების სახელების გამოყენებისას, რომლებიც არა-უარყოფითი რიცხვებია, მასივები ავტომატურად განსაზღვრავს ქონების ღირებულებას სიგრძე... მაგალითად, arr მასივი შეიქმნა ზემოთ ერთი ელემენტით. შემდეგ, მნიშვნელობები გადაეცა მის ელემენტებს ინდექსებით 1, 2 და 3. ამ ოპერაციების შედეგად, მასივის სიგრძის თვისების მნიშვნელობა შეიცვალა და გახდა 4 -ის ტოლი.

თქვენ ნათლად უნდა განასხვავოთ მასივის ინდექსები და ობიექტის თვისებების სახელები. ყველა ინდექსი არის საკუთრების სახელი, მაგრამ მხოლოდ მთელი რიცხვის მქონე თვისებები არის ინდექსი. ყველა მასივი არის ობიექტი და შეგიძლიათ დაამატოთ თვისებები მათ ნებისმიერი სახელით. თუმცა, თუ შეეხებით თვისებებს, რომლებიც მასივის ინდექსია, მასივები რეაგირებენ სიგრძის თვისების მნიშვნელობის განახლებით საჭიროებისამებრ.

გაითვალისწინეთ, რომ უარყოფითი და არა რიცხვები ნებადართულია მასივის ინდექსების სახით. ამ შემთხვევაში, რიცხვები გარდაიქმნება სტრიქონებად, რომლებიც გამოიყენება როგორც საკუთრების სახელები.

მასივის ელემენტების დამატება და ამოღება

ჩვენ უკვე ვნახეთ, რომ მასივის ელემენტების დამატების უადვილესი გზა არის მნიშვნელობების მინიჭება ახალ ინდექსებზე. თქვენ ასევე შეგიძლიათ გამოიყენოთ მეთოდი მასივის ბოლოს ერთი ან მეტი ელემენტის დასამატებლად ბიძგი ():

Var arr =; // ცარიელი მასივის arr.push ("ნულოვანი") შექმნა; // დაამატეთ მნიშვნელობა ბოლოს arr.push ("ერთი", 2); // დაამატეთ კიდევ ორი ​​მნიშვნელობა

თქვენ ასევე შეგიძლიათ დაამატოთ ელემენტი მასივის ბოლოს arr ელემენტის მნიშვნელობის მინიჭებით. მასივის დასაწყისში ელემენტის ჩასასმელად შეგიძლიათ გამოიყენოთ მეთოდი გადაადგილება ()მასივში არსებული ელემენტები გადადის უფრო მაღალ ინდექსებზე.

თქვენ შეგიძლიათ წაშალოთ მასივის ელემენტები წაშლის ოპერატორის გამოყენებით, ობიექტების ჩვეულებრივი თვისებების მსგავსად:

Var arr =; arr წაშლა; 2 arr; // ყალბი, ინდექსი 2 მასივში არის განუსაზღვრელი arr.length; // 3: წაშლის ოპერატორი არ ცვლის მასივის სიგრძის თვისებას

ელემენტის ამოღება მსგავსია (მაგრამ ოდნავ განსხვავებული) ამ ელემენტის განუსაზღვრელი მნიშვნელობის მინიჭებით. გაითვალისწინეთ, რომ მასივის ელემენტზე წაშლის ოპერატორი არ ცვლის სიგრძის თვისებას და არც გადადის უფრო მაღალი ინდექსირებული ელემენტების ქვემოთ ელემენტის წაშლის შემდეგ დარჩენილი სიცარიელის შესავსებად.

გარდა ამისა, შესაძლებელია ელემენტების ამოღება მასივის ბოლოს სიგრძის თვისებაზე ახალი მნიშვნელობის მინიჭებით. მასივებს აქვთ მეთოდი პოპი ()(საპირისპიროა push ()), რომელიც ამცირებს მასივის სიგრძეს 1 -ით და აბრუნებს ამოღებული ელემენტის მნიშვნელობას. ასევე არსებობს მეთოდი ცვლა ()(unshift– ის საპირისპიროდ), რომელიც შლის ელემენტს მასივის დასაწყისში. განსხვავებით წაშლის ოპერატორისაგან, shift () მეთოდი ცვლის ყველა ელემენტს ერთი პოზიციით ქვემოთ მათი ამჟამინდელი მაჩვენებლების ქვემოთ.

დაბოლოს, არსებობს მრავალფუნქციური მეთოდი ნაზავი (), რომელიც საშუალებას გაძლევთ შეიყვანოთ, წაშალოთ და შეცვალოთ მასივის ელემენტები. ის ცვლის სიგრძის თვისების მნიშვნელობას და საჭიროების შემთხვევაში ცვლის მასივის ელემენტებს ქვედა ან უფრო მაღალი ინდექსებით. ჩვენ ყველა ამ მეთოდს განვიხილავთ ცოტა მოგვიანებით.

მრავალგანზომილებიანი მასივები

JavaScript არ უჭერს მხარს "რეალურ" მრავალგანზომილებიან მასივებს, მაგრამ ის კარგად ასრულებს მათ მიბაძვას მასივების მასივების გამოყენებით. მასივის მასივში მონაცემთა ერთეულზე წვდომისათვის საკმარისია ოპერატორის ორჯერ გამოყენება.

მაგალითად, დავუშვათ, რომ ცვლადი მატრიცა არის რიცხვების მასივის მასივი. მატრიცის [x] თითოეული ელემენტი არის რიცხვების მასივი. მასივის კონკრეტულ რიცხვზე წვდომისათვის შეგიძლიათ გამოიყენოთ გამოთქმის მატრიცა [x] [y]. ქვემოთ მოცემულია კონკრეტული მაგალითი, სადაც ორგანზომილებიანი მასივი გამოიყენება როგორც გამრავლების ცხრილი:

// მრავალგანზომილებიანი მასივის შექმნა var table = new Array (10); // ცხრილში არის 10 სტრიქონი for (var i = 0; i

მასივის კლასის მეთოდები

ECMAScript 3 სტანდარტი განსაზღვრავს მასივებთან მუშაობის მრავალ მოსახერხებელ ფუნქციას Array.prototype– ის ნაწილად, რომლებიც ხელმისაწვდომია ნებისმიერი მასივის მეთოდებად. ეს მეთოდები წარმოდგენილი იქნება შემდეგ ქვეთავში.

შეერთება () მეთოდი

Array.join () მეთოდი მასივის ყველა ელემენტს გარდაქმნის სტრიქონებად, აკავშირებს მათ და აბრუნებს მიღებულ სტრიქონს. არჩევითი არგუმენტი შეიძლება გადაეცეს მეთოდს სტრიქონით, რომელიც გამოყენებული იქნება შედეგის სტრიქონის ელემენტების გამოსაყოფად. თუ განმსაზღვრელი სტრიქონი არ არის მითითებული, გამოიყენება მძიმე. მაგალითად, შემდეგი ფრაგმენტი იწვევს სტრიქონს "1,2,3":

Var arr =; arr. შეერთება (); // "1,2,3" arr. შეერთება ("-"); // "1-2-3"

საპირისპირო () მეთოდი

Array.reverse () მეთოდი ცვლის მასივის ელემენტების წესრიგს და აბრუნებს გადალაგებულ მასივს. ჩანაცვლება ხდება უშუალოდ თავდაპირველ მასივზე, ე.ი. ეს მეთოდი არ ქმნის ახალ მასივს გადაკეთებული ელემენტებით, არამედ ხელახლა ალაგებს მათ უკვე არსებულ მასივში. მაგალითად, შემდეგი ფრაგმენტი, რომელიც იყენებს საპირისპირო () და შეერთების () მეთოდებს, იწვევს სტრიქონს "3,2,1":

Var arr =; arr.reverse (). შეერთება (); // "3,2,1"

დახარისხების () მეთოდი

Array.sort () მეთოდი ახარისხებს ელემენტებს თავდაპირველ მასივში და აბრუნებს დახარისხებულ მასივს. თუ დახარისხების () მეთოდს ეძახიან არგუმენტების გარეშე, დალაგება ხდება ანბანის მიხედვით (შედარებისთვის, საჭიროების შემთხვევაში, ელემენტები დროებით გარდაიქმნება სტრიქონებად). განუსაზღვრელი ელემენტები შეფუთულია მასივის ბოლომდე.

თქვენ შეგიძლიათ გაიაროთ შედარების ფუნქცია, როგორც არგუმენტი დასალაგებლად () დასალაგებლად ნებისმიერი სხვა ანბანური თანმიმდევრობით. ეს ფუნქცია ადგენს რომელი ორი არგუმენტიდან უნდა იყოს პირველი დახარისხებულ სიაში. თუ პირველი არგუმენტი წინ უსწრებს მეორეს, შედარების ფუნქცია უნდა დააბრუნოს უარყოფითი რიცხვი. თუ პირველი არგუმენტი უნდა მიჰყვეს მეორეს დახარისხებულ მასივში, მაშინ ფუნქციამ უნდა დააბრუნოს რიცხვი ნულზე მეტი. და თუ ორი მნიშვნელობა ექვივალენტურია (ანუ მათი რიგი არ არის მნიშვნელოვანი), შედარების ფუნქცია უნდა დააბრუნოს 0:

Var arr =; arr.sort (); // ანბანის მიხედვით: 1111, 222, 33, 4 arr.sort (ფუნქცია (a, b) (// რიცხვითი რიგი: 4, 33, 222, 1111 აბრუნებს ab; // აბრუნებს მნიშვნელობას 0 // დამოკიდებულია დალაგებაზე ბრძანება a და b)); // დახარისხება უკან, უმაღლესიდან ყველაზე დაბალ arr.sort (ფუნქცია (a, b) (დაბრუნება b-a));

გაითვალისწინეთ რამდენად მოსახერხებელია ამ ფრაგმენტში უსახელო ფუნქციის გამოყენება. შედარების ფუნქცია გამოიყენება მხოლოდ აქ, ამიტომ არ არის საჭირო მისი სახელის მიცემა.

კონკატის () მეთოდი

Array.concat () მეთოდი ქმნის და აბრუნებს ახალ მასივს, რომელიც შეიცავს ორიგინალური მასივის ელემენტებს, რომლებზედაც დარეკილია concat () მეთოდი და ნებისმიერი არგუმენტის მნიშვნელობები გადადის concat () მეთოდზე. თუ რომელიმე ამ არგუმენტი თავად არის მასივი, მისი ელემენტები ემატება დაბრუნებულ მასივს. თუმცა უნდა აღინიშნოს, რომ არ არსებობს მასივის რეკურსიული გარდაქმნა მასივებიდან ერთგანზომილებიან მასივში. Concat () მეთოდი არ ცვლის თავდაპირველ მასივს. ქვემოთ მოცემულია რამდენიმე მაგალითი:

Var arr =; arr.concat (4, 5); // აბრუნებს arr.concat (); // აბრუნებს arr.concat (,) // აბრუნებს arr.concat (4,]) // ბრუნდება]

ნაჭერი () მეთოდი

Array.slice () მეთოდი აბრუნებს მითითებული მასივის ნაჭერს ან ქვე -მასივს. მეთოდის ორი არგუმენტი განსაზღვრავს დაბრუნებული ნაწილის დაწყებას და დასასრულს. დაბრუნებული მასივი შეიცავს ელემენტს, რომელიც დანომრილია პირველ არგუმენტში პლუს ყველა მომდევნო ელემენტამდე (მაგრამ მათ შორის არ არის) მეორე არგუმენტში დანომრილი ელემენტი.

თუ მხოლოდ ერთი არგუმენტია მითითებული, დაბრუნებული მასივი შეიცავს ყველა ელემენტს საწყისი პოზიციიდან მასივის ბოლომდე. თუ რომელიმე არგუმენტი უარყოფითია, ის განსაზღვრავს ელემენტის ნომერს მასივის ბოლოსთან შედარებით. ასე რომ, არგუმენტი -1 შეესაბამება მასივის ბოლო ელემენტს, ხოლო არგუმენტი -3 შეესაბამება მასივის მესამე ელემენტს ბოლოდან. Აი ზოგიერთი მაგალითი:

Var arr =; arr. ნაჭერი (0.3); // აბრუნებს arr.slice (3); // აბრუნებს arr.slice (1, -1); // აბრუნებს arr.slice (-3, -2); // Დაბრუნდება

Splice () მეთოდი

Array.splice () მეთოდი არის ზოგადი მეთოდი, რომელიც შეიყვანს ან აშორებს ელემენტებს მასივიდან. განსხვავებით slice () და concat () მეთოდებისგან, splice () მეთოდი ცვლის ორიგინალურ მასივს, რომელზეც მას უწოდებდნენ. გაითვალისწინეთ, რომ splice () და slice () მეთოდებს აქვთ ძალიან მსგავსი სახელები, მაგრამ ასრულებენ სრულიად განსხვავებულ ოპერაციებს.

Splice () მეთოდს შეუძლია ამოიღოს ელემენტები მასივიდან, ჩაწეროს ახალი ელემენტები, ან გააკეთოს ორივე ერთდროულად. მასივის ელემენტები გადაინაცვლებს საჭიროებისამებრ ისე, რომ ჩასმის ან წაშლის შემდეგ წარმოიქმნება მომიჯნავე თანმიმდევრობა.

Splice () მეთოდის პირველი არგუმენტი განსაზღვრავს პოზიციას მასივში, საიდანაც ჩასმა და / ან წაშლა. მეორე არგუმენტი განსაზღვრავს მასივიდან ამოღების (ამოჭრის) ელემენტების რაოდენობას. თუ მეორე არგუმენტი გამოტოვებულია, მასივის ყველა ელემენტი ამოღებულია მითითებული მასივიდან მასივის ბოლომდე. Splice () მეთოდი აბრუნებს ამოღებული ელემენტების მასივს, ან (თუ არცერთი ელემენტი არ არის ამოღებული) ცარიელ მასივს.

Splice () მეთოდის პირველი ორი არგუმენტი განსაზღვრავს მასივის ამოღებას. ამ არგუმენტებს შეიძლება მოყვეს ნებისმიერი რაოდენობის დამატებითი არგუმენტი, რომელიც განსაზღვრავს მასივში ჩასასვლელ ელემენტებს, დაწყებული პირველ არგუმენტში მითითებული პოზიციიდან.

Var arr =; arr.splice (4); // აბრუნებს arr = arr. ნაჭერს (1,2); // აბრუნებს arr = arr. ნაჭერს (1,1); // Დაბრუნდება; arr = arr =; arr.splice (2,0, "a", "b"); // Დაბრუნდება; arr =

Push () და pop () მეთოდები

Push () და pop () მეთოდები საშუალებას გაძლევთ იმუშაოთ მასივებით, როგორიცაა დასტები. Push () მეთოდი ამატებს ერთ ან რამდენიმე ახალ ელემენტს მასივის ბოლოს და აბრუნებს მის ახალ სიგრძეს. Pop () მეთოდი ასრულებს საპირისპირო ოპერაციას - ის შლის მასივის ბოლო ელემენტს, ამცირებს მასივის სიგრძეს და უბრუნებს მის ამოღებულ მნიშვნელობას. გაითვალისწინეთ, რომ ორივე ეს მეთოდი შეცვლის თავდაპირველ მასივს, ვიდრე ქმნის მის შეცვლილ ასლს.

Unshift () და shift () მეთოდები

Unshift () და shift () მეთოდები იქცევიან ისევე, როგორც push () და pop (), გარდა იმისა, რომ ისინი შეიყვანენ და აშორებენ ელემენტებს მასივის დასაწყისში და არა ბოლოს. Unshift () მეთოდი ცვლის არსებულ ელემენტებს უფრო დიდი ინდექსებისკენ, რათა გაზარდოს ადგილი, ამატებს ელემენტს ან ელემენტებს მასივის დასაწყისში და აბრუნებს მასივის ახალ სიგრძეს. Shift () მეთოდი შლის და აბრუნებს მასივის პირველ ელემენტს, ყველა მომდევნო ელემენტს ცვლის ერთ პოზიციაზე, რათა დაიკავოს მასივის დასაწყისში დაცლილი სივრცე.

ბოლო განახლება: 09.04.2018

მასივები განკუთვნილია მონაცემთა ნაკრებებთან მუშაობისთვის. მასივის შესაქმნელად გამოიყენება გამოთქმა new Array ().

Var myArray = ახალი მასივი ();

ასევე არსებობს მასივის ინიციალიზაციის უფრო მოკლე გზა:

Var myArray =;

ამ შემთხვევაში, ჩვენ ვქმნით ცარიელ მასივს. თქვენ ასევე შეგიძლიათ დაამატოთ მას საწყისი მონაცემები:

ვარ ხალხი = ["ტომ", "ალისა", "სემი"]; console.log (ხალხი);

ამ შემთხვევაში, myArray– ში იქნება სამი ელემენტი. გრაფიკულად, ის შეიძლება წარმოდგენილი იყოს შემდეგნაირად:

ინდექსები გამოიყენება მასივის ცალკეულ ელემენტებზე. დათვლა იწყება ნულიდან, ანუ პირველ ელემენტს ექნება ინდექსი 0, ხოლო უკანასკნელს ექნება ინდექსი 2:

ვარ ხალხი = ["ტომ", "ალისა", "სემი"]; console.log (ხალხი); // ტომ var person3 = ხალხი; // სემ console.log (person3); // სემი

თუ ჩვენ ვცდილობთ მივიღოთ ელემენტი მასივის ზომაზე დიდი ინდექსით, მივიღებთ განუსაზღვრელ მნიშვნელობას:

ვარ ხალხი = ["ტომ", "ალისა", "სემი"]; console.log (ხალხი); // განუსაზღვრელი

ასევე, ინდექსით, მასივის ელემენტების მნიშვნელობები დადგენილია:

ვარ ხალხი = ["ტომ", "ალისა", "სემი"]; console.log (ხალხი); // ტომ ხალხი = "ბობ"; console.log (ხალხი); // ბობ

უფრო მეტიც, სხვა ენებისგან განსხვავებით, როგორიცაა C # ან Java, შეგიძლიათ დააინსტალიროთ ელემენტი, რომელიც თავდაპირველად არ იყო დაინსტალირებული:

ვარ ხალხი = ["ტომ", "ალისა", "სემი"]; console.log (ხალხი); // განუსაზღვრელი - მასივის ხალხში არის მხოლოდ სამი ელემენტი = "ბობ"; console.log (ხალხი); // ბობ

ასევე აღსანიშნავია, რომ JavaScript– ის მრავალი პროგრამირების ენისგან განსხვავებით, მასივები არ არის მკაცრად აკრეფილი, ერთ მასივს შეუძლია შეინახოს სხვადასხვა ტიპის მონაცემები:

Var ობიექტები = ["ტომ", 12, ჭეშმარიტი, 3.14, ყალბი]; console.log (ობიექტები);

გავრცელების ოპერატორი

გავრცელების ოპერატორი ... გაძლევთ საშუალებას მიიღოთ მნიშვნელობები მასივიდან ცალკე:

მოდით რიცხვები =; console.log (... ნომრები); // 1 2 3 4 console.log (რიცხვები); //

სპრედის ოპერატორი მითითებულია მასივამდე. შედეგად, გამოთქმა ... რიცხვები დააბრუნებს რიცხვების ერთობლიობას, მაგრამ ეს არ იქნება მასივი, არამედ ინდივიდუალური მნიშვნელობები.

მრავალგანზომილებიანი მასივები

მასივები შეიძლება იყოს ერთგანზომილებიანი და მრავალგანზომილებიანი. მრავალგანზომილებიანი მასივის თითოეული ელემენტი შეიძლება იყოს ცალკე მასივი. ზემოთ განვიხილეთ ერთგანზომილებიანი მასივი, ახლა მოდით შევქმნათ მრავალგანზომილებიანი მასივი:

ვარ რიცხვები 1 =; // ერთგანზომილებიანი მასივი var numbers2 = [,]; // ორგანზომილებიანი მასივი

ვიზუალურად, ორივე მასივი შეიძლება წარმოდგენილი იყოს შემდეგნაირად:

ერთგანზომილებიანი მასივის რიცხვები 1

მასივის ერთი ელემენტის მისაღებად ინდექსი ასევე გამოიყენება:

Var tomInfo = ხალხი;

მხოლოდ ახლა tomInfo ცვლადი წარმოადგენს მასივს. ჩადგმული მასივის შიგნით ელემენტის მისაღებად, ჩვენ უნდა გამოვიყენოთ მისი მეორე განზომილება:

Console.log ("სახელი:" + ხალხი); // ტომ console.log ("ასაკი:" + ხალხი); // 25

ანუ, თუ ჩვენ შეგვიძლია ვიზუალურად წარმოვადგინოთ ორგანზომილებიანი მასივი ცხრილის სახით, მაშინ ხალხის ელემენტი ეხება ცხრილის უჯრედს, რომელიც მდებარეობს პირველი რიგისა და მეორე სვეტის კვეთაზე (პირველი განზომილება არის 0 - რიგი, მეორე განზომილება - 1 - სვეტი).

ჩვენ ასევე შეგვიძლია დავალების შესრულება:

ვარ ხალხი = [["ტომ", 25, ყალბი], ["ბილი", 38, ჭეშმარიტი], ["ალისა", 21, ყალბი]]; ხალხი = 56; // მიანიჭეთ ცალკე მნიშვნელობის კონსოლი.ლოგი (ხალხი); // 56 ადამიანი = ["ბობ", 29, ყალბი]; // მასივის კონსოლის მინიჭება. log (ხალხი); // ბობ

მრავალგანზომილებიანი მასივების შექმნისას, ჩვენ არ შემოვიფარგლებით მხოლოდ ორგანზომილებიანი მასივებით, მაგრამ ასევე შეგვიძლია გამოვიყენოთ დიდი ზომების მასივები:

ვარ რიცხვები =; რიცხვები =; // ახლა რიცხვები არის ორგანზომილებიანი მასივის რიცხვები =; // ახლა რიცხვები არის სამგანზომილებიანი მასივის რიცხვები = 5; // 3D მასივის პირველი ელემენტია 5 console.log (რიცხვები);

მივესალმოთ ყველას, ვინც დაინტერესებულია JavaScript მრავალგანზომილებიანი მასივებით და დახარისხებით. ახლანდელ პუბლიკაციაში შევეცდები ეს თემა ყველა დეტალი გავხსნა.

ამიტომ, ამ სტატიის წაკითხვის შემდეგ თქვენ გაიგებთ, თუ რატომ გამოიყენება მრავალგანზომილებიანი მასივები ვებ აპლიკაციებში, როგორ იქმნება და როგორ ხდება მათი მანიპულირება და დახარისხება. მოდით გადავიდეთ სწავლაზე!

როგორ იქმნება და რისთვის არის მრავალგანზომილებიანი მასივები?

დასაწყისისთვის, უნდა გვახსოვდეს, თუ როგორ იქმნება რეგულარული ერთგანზომილებიანი მასივი.

var მასივი =

ახლა გახსოვდეთ, რომ მრავალგანზომილებიანი მასივი არის მასივების მასივი.გეთანხმები, ჟღერს ტავტოლოგია. თუმცა, კვლავ წაიკითხეთ განმარტება. მართლაც, მრავალგანზომილებიანი მასივი შედგება გარკვეული რაოდენობის ბუდეებისაგან.

განვიხილოთ შემდეგი სიტუაცია. თამაშის დაწყებისას მომხმარებელი შეიყვანს მის სახელს, ხოლო დასრულების შემდეგ ეკრანზე გამოჩნდება მოთამაშეთა სახელების და მათი ჩანაწერების სარეიტინგო ცხრილი.

ნათელია, რომ ასეთი ინფორმაცია ინახება მონაცემთა ბაზაში. მაგრამ როდესაც ჩვენ გამოვიყვანთ მას მონაცემთა ბაზიდან, ვიღებთ მრავალგანზომილებიან მასივს. ყოველივე ამის შემდეგ, თითოეული ქვეარხი შეიცავს მოთამაშის ავტორიზაციას და ქულების რაოდენობას.

ეს ყველაფერი ასე გამოიყურება:

var შედეგები = [["მარკუსი", 333], ["ნატაშა", 211], ["ალექსეი", 124]];

როგორც ხედავთ, ინფორმაციის შენახვა შესაძლებელია არაერთგვაროვანი. ეს შეიძლება იყოს სტრიქონები, რიცხვები და თუნდაც. ეს შესაძლებელია, რადგან მასივები დაუწერელია.

ამ შემთხვევაში, ელემენტებზე წვდომა ხდება ორმაგი ოპერატორის საშუალებით.

მასალის კონსოლიდაციისთვის გაანალიზეთ მცირე პროგრამა.

შედეგები =

მასივები საკმაოდ მოსახერხებელი გზაა შენახული რთული მონაცემების შესანახად მათი დამუშავებისას. გარდა ამისა, ძალიან მოსახერხებელია მათთან მუშაობა და, ამავდროულად, მათი დამუშავების სიჩქარე საკმაოდ მაღალია.

მონაცემთა დახარისხების მეთოდები

მასივებისთვის JavaScript– ში არის ჩაშენებული მეთოდი, სახელწოდებით დალაგება ()... ეს ინსტრუმენტი ძალიან მოქნილია. ახლა კი აგიხსნით რატომ.

თუ თქვენ იყენებთ მეთოდს პარამეტრების გარეშე, მაშინ ის ავტომატურად უბრძანებს ქვესარხებს პირველი ელემენტის მიხედვით ანბანის მიხედვით. ასე რომ, დარეკვისას შედეგები.დალაგება ()გაანალიზებული ობიექტი ასე გამოიყურება:

ალექსეი, 124

მარკუსი, 333

ნატაშა, 211

და თუ თქვენ შეცვლით ელემენტებს თითოეულ ჩადგმულ მასივში, მიიღებთ:

124, ალექსეი

211, ნატაშა

333, მარკუსი

ამ შემთხვევაში, შედარებისთვის, ყველა ელემენტი დროებით გარდაიქმნება სტრიქონებად.

თუ კონკრეტული ამოცანის გადასაჭრელად გჭირდებათ ფუნქცია, რომელიც ახორციელებს ელემენტების არასტანდარტულ დახარისხებას, მაშინ თქვენ თვითონ შეგიძლიათ დაწეროთ იგი და გადასცეთ ის როგორც პარამეტრი დალაგება ()... უნდა გვახსოვდეს, რომ საბაჟო ფუნქცია უნდა დაბრუნდეს:

• დადებითი რიცხვი (ზოგადად აირჩიეთ 1), თუ პირველი მითითებული პუნქტი მიჰყვება მეორეს შედარებისას;
• უარყოფითი რიცხვი (ჩვეულებრივ -1), თუ მეორე შერჩეული ელემენტი უნდა მოყვეს პირველს;
• ნული, თუ ორი შემოწმებული მნიშვნელობა ტოლია.

მაგალითისთვის ავიღოთ საწყისი მასივი შედეგებიდალაგება წერტილების მიხედვით. უფრო მეტიც, შედეგები დალაგდება უმაღლესიდან ყველაზე დაბალამდე. ეს შეიძლება გაკეთდეს ორი გზით.

პირველ ვერსიაში მე შევცვალე დახარისხების ლოგიკა, ე.ი. იმ სიტუაციაში, როდესაც აუცილებელია დადებითი რიცხვის დაბრუნება, მე უარყოფითს და პირიქით.

ჩანაწერების ცხრილი:

მაგრამ მეორე მეთოდით, დახარისხების ლოგიკა ხელუხლებელი დავტოვე, მაგრამ დამატებით გამოვიყენე სხვა მეთოდი - საპირისპირო ()... როგორც სახელი გვთავაზობს, საპირისპირო ცვლის ელემენტების წესრიგს.

ამიტომ, დალაგების () ფუნქცია ასე გამოიყურება:

ფუნქცია RecordSort (a, b) (if (a> b) return 1; else if (a< b) return -1; else return 0; }

ამის შემდეგ, დავამატოთ ზემოთ მეთოდი.

დასკვნა გაკეთებულია ანალოგიურად.

მინდა თქვენი ყურადღება გავამახვილო ერთ მნიშვნელოვან პუნქტზე. ამ ფუნქციების გამოყენებისას, ყველა ცვლილება ხდება მასივში, რომელზეც მათ იყენებთ. ამრიგად, თუ თქვენ გჭირდებათ მონაცემების ორიგინალური ფორმის შენარჩუნება, შემდეგ შექმენით ასლი და შემდეგ შეცვალეთ იგი.

ასე რომ, მე ვისაუბრე მრავალგანზომილებიან მასივებზე და მათ დახარისხებაზე. თუ მოგეწონა სტატია, მაშინ გამოიწერე ბლოგი და წაიკითხე სხვა თანაბრად საინტერესო პუბლიკაციები. მადლობელი ვიქნები გამოქვეყნებისთვის. შემდეგ ჯერზე!

Ნახვამდის!

პატივისცემით, რომან ჩუეშოვი