ჩადგმული ჯავასკრიპტის მასივები. მასივის ელემენტების ამოღება. მოკლე აღნიშვნა: კვადრატული ფრჩხილების გამოყენებით

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

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

ქვემოთ მოცემულია JS-ში მასივებით მუშაობის ძირითადი მეთოდები.

ბიძგი

push() მეთოდი ამატებს მნიშვნელობას მასივის ბოლოს.

მოდით arr = ; arr.push(312); console.log(arr); // →

პოპ

pop() მეთოდი შლის ბოლო ელემენტს მასივიდან ან აბრუნებს მის მნიშვნელობას.

მოდით arr = ; arr.pop(); console.log(arr); // →

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

მოდით img = "https://example.com/img/name.png"; let format = img.split(".").pop(); console.log(format); // → png console.log(img.split(".")); // → ["https://example", "com/img/name", "png"]

უცვლელი

unshift() მეთოდი ამატებს ელემენტს მასივის დასაწყისში.

მოდით arr = ; arr.unshift(312); console.log(arr); // →

ცვლა

shift() მეთოდი შლის პირველ ელემენტს მასივიდან.

მოდით arr = ; arr.shift(); console.log(arr); // → ;

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

გაყოფა

split() მეთოდი გამოიყენება სტრიქონის მასივად გადაქცევისთვის. Split ყოფს სტრიქონს მითითებული პარამეტრის მიხედვით.

მოდით str = "ანა, მაშა, საშა, დაშა"; // ეს არის სტრიქონი let arr = str.split(", "); console.log(arr); // → ["ანა", "მაშა", "საშა", "დაშა"] არის მასივი

შეუერთდი

join() მეთოდი აერთიანებს მასივის ელემენტებს სტრიქონში პარამეტრში მითითებული დელიმიტერის გამოყენებით.

მოდით arr = ["Notpad++", "Sublime", "VSCode"]; // ეს არის მასივი მოდით str = arr.join(", "); console.log("კოდის რედაქტორები: " + str); // → "კოდის რედაქტორები: Notpad++, Sublime, VSCode"

ნაჭერი

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

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

slice მეთოდი არ ცვლის თავდაპირველ მასივს.

აქ მოცემულია slice() მეთოდის რამდენიმე მაგალითი მოქმედებაში:

მოდით arr = ["A", "B", "C", "D", "E", "F", "G"]; // აბრუნებს მასივს, რომელიც შეიცავს ელემენტებს 2-დან 5-მდე ინდექსებით console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // აბრუნებს ახალ მასივს, რომელიც შეიცავს ელემენტებს ინდექსებით 3-დან arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // აბრუნებს ორიგინალური მასივის ასლს console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // აბრუნებს ახალ მასივს, რომელიც შედგება ორიგინალური კონსოლის ბოლო სამი ელემენტისგან.log (arr.slice (-3)); // → ["E", "F", "G"]

შერწყმა

splice() მეთოდი ცვლის მასივის შიგთავსს არსებული ელემენტების ამოღებით და/ან ახლის დამატებით.

სინტაქსი:

Array.splice(დაწყება, წაშლა რაოდენობა[, ელემენტი1[, ელემენტი2[, ...]]])

პარამეტრები:

• start - ინდექსი, რომლითაც უნდა დაიწყოს მასივის შეცვლა. თუ მასივის სიგრძეზე მეტია, რეალური ინდექსი დაყენდება მასივის სიგრძეზე. თუ უარყოფითია, მიუთითებს ელემენტის ინდექსს ბოლოდან.
• deleteCount - მთელი რიცხვი, რომელიც მიუთითებს მასივიდან წასაშლელი ძველი ელემენტების რაოდენობაზე. თუ deleteCount არის 0, არცერთი ელემენტი არ წაიშლება. ამ შემთხვევაში, თქვენ უნდა მიუთითოთ მინიმუმ ერთი ახალი ელემენტი. თუ deleteCount მეტია მასივში დარჩენილი ელემენტების რაოდენობაზე, რომელიც იწყება ინდექსის დაწყებიდან, მაშინ მასივის ბოლომდე ყველა ელემენტი წაიშლება.
• itemN - არჩევითი პარამეტრები. ელემენტები, რომლებიც უნდა დაემატოს მასივს. თუ რომელიმე ელემენტს არ მიუთითებთ, splice() უბრალოდ ამოიღებს ელემენტებს მასივიდან.

დაბრუნების ღირებულების აღწერა

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

Let arr = ["ბარსა", "შახტარი", "მანჩესტერ იუნაიტედი", "მილანი", "რეალი", "აიაქსი", "იუვენტუსი"]; მოდით nax = arr.splice(2, 3); arr.splice(2, 3); console.log(nax); // → ["მანჩესტერ იუნაიტედი", "მილანი", "რეალი"] console.log(arr); // → ["ბარსა", "შახტარი"] arr.splice(1, 0, "ზენიტი", "ცსკა", "სპარტაკი"); console.log(arr); // → [ბარსა, ზენიტი, ცსკა, სპარტაკი, შახტარი]

საპირისპირო

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

მოდით arr = ; console.log(arr.reverse()); // → console.log(["Alice", "BG", "GO", "DDT"].reverce()); // → ["DDT", "GO", "BG", "Alice"]

რუკა

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

ქვემოთ მოცემულ მაგალითში, მასივის თითოეულ ელემენტს ვამატებთ ამ ელემენტის ინდექსის მნიშვნელობას (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

მოდით arr = ; მოდით testMap = arr.map((ელემენტი, ინდექსი) => ელემენტი + ინდექსი); console.log (testMap); //

ან გავამრავლოთ მასივის თითოეული მნიშვნელობა, მაგალითად, 12-ზე

მოდით arr = ; მოდით testMap = arr.map(a => a * 12); console.log (testMap); // →

ფილტრი

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

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

მოდით arr = ; მოდით testFilter = arr.filter(element => ელემენტი > 21); console.log (testFilter); // →

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

შემცირება

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

ეს მეთოდი ხშირად გამოიყენება მასივის ყველა რიცხვის ჯამის საპოვნელად. მაგალითი:

მოდით arr = ; მოდით summa = arr.reduce((acc, ელემენტი) => acc + ელემენტი); console.log(sum); // → 370

დალაგება

sort() მეთოდი გამოიყენება მასივის ელემენტების განსაზღვრული პარამეტრების მიხედვით დასალაგებლად.

მაგალითი - ავიღოთ რიცხვების მასივი და დავახარისხოთ ისინი ზრდადობის მიხედვით:

მოდით arr = ; მოდით testSortArr = arr.sort((a, b) => a - b); console.log (testSortArr); // →

მოიცავს

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

გამოყენების მაგალითი მოიცავს() .

აი ლოგიკური გამოთქმა:

მოდით ცხოველი = "ძაღლი"; თუ (ცხოველი == "კატა" || ცხოველი == "ძაღლი" || ცხოველი == "ლომი" || ცხოველი == "ცხენი") (// ........ )

მოიცავს მეთოდის გამოყენებით შეგიძლიათ დაწეროთ ასე:

მოდით ცხოველი = "ძაღლი"; const animals = ["კატა", "ძაღლი", "ლომი", "ცხენი"]; თუ (ცხოველები. მოიცავს (ცხოველს)) ( // ........... )

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

Var mas = new Array(value1, value2,..., valueN);

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

var mas = ახალი მასივი ("privet", 1, 10, 5); document.write("მეორე მასივის ელემენტი = "+mas); // გამოჩნდება ნომერი 10

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

var mas = ახალი მასივი ("privet", 1, 10, 5); document.write("მასივის სიგრძე = "+mas.length); // გამოჩნდება ნომერი 4

მასივის ყველა ელემენტის დაბეჭდვა:

var mas = ახალი მასივი ("privet", 1, 10, 5); var i; ამისთვის (i = 0; i< mas.length; i++) document.write(mas[i]+" ");

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

var mas = new Array(); //გამოაცხადეთ მასივი const n = 3; //გამოაცხადეთ მუდმივი, ე.ი. ჩვენი მასივი ზომით არის 3-ზე 3 //ორგანზომილებიანი მასივის განსასაზღვრად, უნდა გამოიყენოთ ორმაგი ციკლი var i; var j; ამისთვის (i = 0; i< n; i++) { mas[i] = new Array();//Здесь мы как раз каждый элемент массива делаем массивом for (j = 0; j < n; j++) { mas[i][j] = prompt("[" + i +","+j+"]= " ,"..."); //запрашиваем число у пользователя } } for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { document.write("[" + i +","+j+"]= "+ mas[i][j]);} //выводим элемент массива document.write("
"); // გადადით ახალ ხაზზე მასივის თითოეული შევსებული მწკრივის შემდეგ)

ჩვენს შემთხვევაში, ორგანზომილებიანი მასივი შეესაბამება (მაგალითად) შემდეგ სტრუქტურას: mas=[,,] . თქვენ ხედავთ, რომ მასივს აქვს 3 ელემენტი, რომელთაგან თითოეული თავად არის მასივი.

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

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

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

1. მასივებზე მორგებული თვისებების დამატება

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

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

2. მასივის ელემენტებზე წვდომა მარყუჟის ფარგლებში

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

ECMAScript6-მა წარმოადგინა მასივის გადახვევის გზა ინდექსების გამოყენების გარეშე, მაგრამ ახალი for…-ის მარყუჟის მეშვეობით.

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

Var ary = ["ფორთოხალი", "ვაშლი", "ლიჩი"]; for (let item of ary)( console.log(item); ) // "orange", "apple", "lychee" შედარებისთვის: ნივთების ინდექსების გამოტანა for loop-ში. var ary = ["ფორთოხალი", "ვაშლი", "ლიჩი"]; for (var ელემენტი = 0; ელემენტი< ary.length; item++){ console.log(item); } // 0, 1, 2

3. ელემენტების რაოდენობა არ არის მასივის განზომილება

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

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

ვარარი = ; არი.სიგრძე = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6

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

ვარარი = ; არი.სიგრძე = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 in ary); // ყალბი

ამ შემთხვევაში, სამართლიანი იქნება, ary მასივს "მწირი" ვუწოდოთ.

ჩვენ ასევე შეგვიძლია სიგრძის თვისების მანიპულირება მასივების მორთვისთვის. ქვემოთ მოყვანილი მაგალითი გვიჩვენებს ელემენტის „დაკარგვას“ ინდექსში 5, არით მასივის სიგრძის თვისების შემცირებით.

ვარარი = ; არი.სიგრძე = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 არი.სიგრძე = 2; console.log(ary.length); // 2 console.log(ary); // განუსაზღვრელი

• თარგმანი

• I. გამეორება რეალურ მასივებზე
• თითოეული მეთოდისთვის და მასთან დაკავშირებული მეთოდებისთვის
• მარყუჟისთვის
• მარყუჟის for...in-ის სწორად გამოყენება
• for... of loop (იტერატორის ფარული გამოყენება)
• იტერატორის აშკარა გამოყენება
• რეალური მასივების გამეორების მეთოდების გამოყენება
• გადაიყვანეთ რეალურ მასივში
• შენიშვნა გაშვების ობიექტებზე

I. გამეორება რეალურ მასივებზე ამ დროისთვის, არსებობს რეალური მასივის ელემენტებზე გამეორების სამი გზა:

მეთოდი Array.prototype.forEach;

კლასიკური მარყუჟისთვის

"სწორად" აგებული... მარყუჟისთვის.

გარდა ამისა, მალე, ახალი ECMAScript 6 (ES 6) სტანდარტის მოსვლასთან ერთად, მოსალოდნელია კიდევ ორი ​​მეთოდი:

for...of loop (იტერატორის იმპლიციტური გამოყენება);

იტერატორის აშკარა გამოყენება.

1. ForEach მეთოდი და მასთან დაკავშირებული მეთოდები თუ თქვენი პროექტი შექმნილია ECMAScript 5 (ES5) სტანდარტის მახასიათებლების მხარდასაჭერად, შეგიძლიათ გამოიყენოთ მისი ერთ-ერთი ინოვაცია - forEach მეთოდი.

გამოყენების მაგალითი:
var a = ["ა", "ბ", "გ"]; a.forEach(function(entry) ( console.log(entry); ));
ზოგადად, forEach-ის გამოყენება მოითხოვს es5-shim ემულაციის ბიბლიოთეკის დაკავშირებას ბრაუზერებისთვის, რომლებიც არ უჭერენ მხარს ამ მეთოდს. მათ შორისაა IE 8 და უფრო ადრე, რომლებიც ჯერ კიდევ გამოიყენება ზოგიერთ ადგილას.

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

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

ForEach შექმნილია მასივის ყველა ელემენტზე გამეორებისთვის, მაგრამ გარდა ამისა, ES5 გვთავაზობს კიდევ რამდენიმე სასარგებლო მეთოდს ყველა ან ზოგიერთ ელემენტში გამეორებისთვის და მათზე გარკვეული მოქმედებების შესრულება:

• every - აბრუნებს true თუ მასივის თითოეული ელემენტისთვის გამოძახება აბრუნებს მნიშვნელობას, რომელიც შეიძლება გარდაიქმნას true-ში.
• some - აბრუნებს true, თუ მასივის მინიმუმ ერთი ელემენტისთვის გამოძახება აბრუნებს მნიშვნელობას, რომელიც შეიძლება გარდაიქმნას true-ში.
• filter - ქმნის ახალ მასივს, რომელიც მოიცავს ორიგინალური მასივის იმ ელემენტებს, რომლებისთვისაც გამოძახება უბრუნებს true.
• რუქა - ქმნის ახალ მასივს, რომელიც შედგება გამოძახებით დაბრუნებული მნიშვნელობებისაგან.
• შემცირება - ამცირებს მასივს ერთ მნიშვნელობამდე, რიგრიგობით მიმართავს მასივის თითოეულ ელემენტს, დაწყებული პირველით (შეიძლება გამოადგეს მასივის ელემენტების ჯამის და სხვა შემაჯამებელი ფუნქციების გამოსათვლელად).
• reduceRight - მუშაობს ისევე, როგორც შემცირება, მაგრამ მეორდება ელემენტების მეშვეობით საპირისპირო თანმიმდევრობით.

2. მარყუჟისთვის კარგი ძველი წესებისთვის:

Var a = ["a", "b", "c"]; var ინდექსი; for (ინდექსი = 0; ინდექსი< a.length; ++index) { console.log(a); }
თუ მასივის სიგრძე მარყუჟის მანძილზე მუდმივია და თავად მარყუჟი ეკუთვნის კოდის შესრულების კრიტიკულ განყოფილებას (რაც ნაკლებად სავარაუდოა), მაშინ შეგიძლიათ გამოიყენოთ "უფრო ოპტიმალური" ვერსია, რომელიც ინახავს კოდის სიგრძეს. მასივი:

Var a = ["a", "b", "c"]; var ინდექსი, len; for (ინდექსი = 0, len = a.სიგრძე; ინდექსი< len; ++index) { console.log(a); }
თეორიულად, ეს კოდი წინაზე ცოტა უფრო სწრაფად უნდა მუშაობდეს.

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

Var a = ["a", "b", "c"]; var ინდექსი; for (index = a.length - 1; index >= 0; --index) (consol.log(a); )
თუმცა, თანამედროვე JavaScript ძრავებში ასეთი ოპტიმიზაციის თამაშები ჩვეულებრივ არაფერს ნიშნავს.

3. for...in loop-ის სწორი გამოყენება თუ გირჩევთ გამოიყენოთ for...in loop, გახსოვდეთ, რომ მასივების გამეორება არ არის ის, რისთვისაც ის არის განკუთვნილი. გავრცელებული მცდარი წარმოდგენის საწინააღმდეგოდ, for...in ციკლი არ იმეორებს მასივის ინდექსებს, არამედ ობიექტის უთვალავი თვისებების მეშვეობით.

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

// a - მწირი მასივი var a = ; a = "a"; a = "ბ"; a = "c"; for (var key in a) ( if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key