მასივის გამოყენება JavaScript-ში. ორგანზომილებიანი მასივი JavaScript-ში. ცალმხრივი მასივის ნომრები1
სტატიის წინა ნაწილში ვისაუბრეთ მათზე, ვინც ამას აკეთებს და როგორ ვიმუშაოთ მასთან. ამ სტატიებში ჩვენ ვისაუბრებთ მდიდარი მასივი.
Tse მასივი, რომელსაც აქვს ერთი ან მეტი ელემენტი - ასევე მასივები. Zalezhno vіd glibini goloshennya, zokrema, vіn შეიძლება ეწოდოს ორგანზომილებიანი მასივი(2 უდრის) ან ტრივიალური მასივი(3 მანეთი) ან ჩოტირივიმირნიმი(4 უდრის) თხელი.
ყველაზე პოპულარული, ერთი მსოფლიო მასივის შემდეგ, რომელიც ყველაზე პოპულარულია ორი სამყაროს მასივი. იგივე yogo, vicimo ანგარიში.
ბაჩიტის მსგავსად, ორი სამყაროს მასივის ელემენტები არის ერთი სამყაროს მასივები. Yakbi tsі odnomirnі masivi შურისმაძიებელი masiv, array arr buv bi უკვე ტრივიალურია.
მაგალითად, შევქმნათ სამი მარტივი მასივი და დავიმახსოვროთ ისინი. ჩვენ გვახსოვს პირველი დაწყვილებული ნომრებით, მეორე - დაუწყვილებელი ნომრებით და მესამე - საკმარისი ხარკით.
//ხმა სამი ცარიელი მასივი var evenNumbers = new Array(); //k-ის შეცვლა - მასივის ინდექსისთვის evenNumbers var k = 0; var oddNumbers = new Array(); //Change n - მასივის ინდექსისთვის oddNumbers var n = 0; var data = new Array("car", "plane", true, 89, "m"); //ჩვენ ვინახავთ ლუწ Numbers მასივს, ორმაგი ნომრებით for(var i = 1; i
იმისათვის, რომ გაოცდეთ რა არის მასივის შუაში, შეგიძლიათ დააჩქაროთ ისეთი ხელსაწყოთი, როგორიცაა კონსოლი.
მაგალითად, ჩვენ გვინდა მასივი დავამთხვიოთ დაუწყვილებელ რიცხვებთან oddNumbers. ვისთვისაც ქვემოთ მოცემულ კოდში ვწერთ შემდეგ რიგს:
Console.log (oddNumbers);
შედეგის გასაუმჯობესებლად აუცილებელია ჩვენება ბრაუზერის კონსოლი. AT გუგლ ქრომივიბრძოლოთ ასე: ვაჭერთ მაუსის მარჯვენა ღილაკს გვერდზე და კონტექსტური მენიუაირჩიეთ დატოვოთ ვარიანტი "შეხედე კოდს", შემდეგ ინსპექტორი. AT ინგლისური ვერსია, რომელ ვარიანტს ეწოდება Inspect.
საცალო ვაჭრობის ხელსაწყოთა პანელი გამოჩნდება ქვემოთ. თქვენ უნდა გადახვიდეთ კონსოლის ჩანართზე.
ახლა ამისთვის შექმენით ორმაგი მასივიაუცილებელია იოგას გახმოვანება და მისი დამატება ახალ ერთ-მსოფლიო მასივში, თითქოს მათ შექმნეს მეტი.
//2Dimens მასივის გადააჭარბეთ და დააბრუნეთ var twoDimens = new Array( evenNumbers, oddNumbers, data); კონსოლის ჟურნალი (twoDimens);
მოდით შევხედოთ კონსოლს ამ მასივის ნაცვლად.
ორი სამყაროს მასივის ჩამოთვლა
დასაწყისისთვის, მოდით ვისწავლოთ როგორ მივმართოთ ორი სამყაროს მასივის ელემენტებს.
ცალკეული მასივების მსგავსად, ელემენტების მასშტაბირება ხორციელდება სხვადასხვა ინდექსებისთვის.
მაგალითად, მოდით გამოვაჩინოთ ელემენტი ინდექსში 3 კენტი რიცხვების მასივში (oddNumbers). ერთი სამყაროს მასივის ინდექსი არის oddNumbers, რომ ორ სამყაროს მასივი 2Dimens უდრის (1).
Document.write("ელემენტი 3 ინდექსით oddNumbers დაუწყვილებელი რიცხვების მასივისთვის უკეთესია: "+ twoDimens); // ელემენტი: 7
TwoDimens მასივში, ჩვენ გადავდივართ ელემენტზე 1 ინდექსით. ელემენტი, რომელიც არის ინდექსის ქვეშ არის oddNumbers მასივი. და ამ მასივში ჩვენ უკვე მივდივართ ელემენტზე 3 ინდექსით, რაც არის 7.
ახლა მოდით გადავიდეთ საჭმელზე. როგორ გავიმეოროთ ორი სამყაროს მასივი.
ორი სამყაროს მასივის ჩამოთვლა ხორციელდება ზედაპირული ციკლის მხარდასაჭერად. მაგალითად, მოდით დავახარისხოთ ჩვენი 2Dimens მასივი.
For(var i = 0; i< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("
ელემენტი ინდექსით " + i + " " + j + "დორივნიუє: + ორიგანზომილებიანი[i][j] +"
"); } }პირველი ციკლისთვის ჩვენ გავძარცვეთ 2Dimens მასივი. სხვა ციკლში ჩვენ უკვე უნდა დავახარისხოთ თავად ელემენტი (მასივი). მეორეს მხრივ, შეცვალეთ i 0-ზე. სხვა ციკლში, მეორეს მხრივ, ჩვენ ვმუშაობთ ჩამოვთვალოთ პირველი მასივი evenNumbers, რომელსაც შეიძლება ჰქონდეს ინდექსი 0. და უკვე მეორე ციკლის შუაში, მივდივართ ამ მასივის ელემენტები. ასევე: twoDimens[j]. ის იცვლება 0-დან j-მდე ლუწი რიცხვების მასივში.
პირველი მასივიდან ელემენტების გამეორების შემდეგ, პირველ ციკლზე გადაბრუნების შემდეგ, თანდათანობით იცვლება i, და გადავდივართ სხვა კენტი რიცხვების მასივის გამეორებაზე, რომელსაც შეიძლება ჰქონდეს ინდექსი 1. ასე რომ, ღერძი ცდილობს ჩამოთვალოს ორიგანზომილების კანის ელემენტი. მასივი.
ახლა მოდით შევხედოთ ჩამოთვლის შედეგს:
ღერძი და ყველაფერი იმის შესახებ, რისი თქმაც მინდა ამ სტატიაში. ახლა თქვენ იცით, როგორ შექმნათ ორი სამყაროს მასივი, როგორ მივმართოთ ორ სამყაროს მასივის ელემენტებს და როგორ დაალაგოთ ორ სამყაროს მასივი. ვფიქრობ, ყველაფერს აზრი ჰქონდა. გისურვებ დიდ წარმატებებს!
- I. რეალური მასივების ჩამოთვლა
- იაკის მეთოდი და საკამათო მეთოდები
- მარყუჟისთვის
- for...in ციკლის გამოყენების სწორი გზა
- for... of loop (იმპლიციტურად განმეორებითი ცვლადი)
- ცალსახად იტერატორის გამოყენებით
- ვიკორისტანია რეალური მასივების ჩამოთვლის გზები
- კონვერტაცია სწორ მასივში
- პატივისცემა ობიექტური შუა vikonannya
I. რეალური მასივების ჩამოთვლა
Ზე ნარაზისაცნობარო მასივის ელემენტებზე გამეორების სამი გზა არსებობს:- მეთოდი Array.prototype.forEach;
- კლასიკური მარყუჟისთვის;
- "სწორად" იწვევს for...in ციკლს.
- for...of loop (იმპლიციტურად iterator ცვლადი);
- აშკარად განმეორებითი არჩევანია.
1. მეთოდი თითოეული და საკამათო მეთოდები
თითქოს თქვენი პროექტი ხელს უწყობს ECMAScript 5 (ES5) შესაძლებლობების სტანდარტს, შეგიძლიათ შეამოწმოთ ერთი ახალი ფუნქცია - forEach მეთოდი.ვიკორისტანის მაგალითი:
var a = ["ა", "ბ", "გ"]; a.forEach(function(entry) ( console.log(entry); ));
ველური გზით, forEach იყენებს es5-shim ემულაციის ბიბლიოთეკას ბრაუზერებისთვის, რათა არ შეძლოს ამ მეთოდის მშობლიური მხარდაჭერა. მათ წინ IE 8 და მეტი ჩანს ადრეული ვერსიები, yakі dosі de-not-de მაინც vikoristovuyutsya.
თითოეულის წინ არიან ისეთები, რომლებსაც არ სჭირდებათ ლოკალური ცვლილებების გახმოვანება ინდექსის და ნაკადის ელემენტის მნიშვნელობის მასივში შესანახად, stink shards ავტომატურად გადაეცემა გამოძახების ფუნქციას, როგორც არგუმენტები.
თუ თქვენ შეგიძლიათ იყოთ ტურბულენტური კანის ელემენტის ყოველკვირეული გამოძახებისას, არ იწუწუნოთ და წაიკითხეთ.
ForEach დავალებები მასივის ყველა ელემენტზე გამეორებისთვის, მაგრამ ES5 წარმოგიდგენთ რამდენიმე ძირითად მეთოდს ყველა ან სხვა ელემენტზე გამეორებისთვის, პლუს აკრეფა, როდესაც მათთან არის რამდენიმე სხვა:
- ყოველი - turn true, ასე რომ კანის ელემენტისთვის გამოძახების მასივი აქცევს მნიშვნელობებს, რომლებიც გადაყვანილია true-ზე.
- some-turn true, თუ გსურთ გადააბრუნოთ მნიშვნელობა ერთი ელემენტის გამოძახების მასივში, რომელიც გადაიცემა true-ზე.
- filter - შექმენით ახალი მასივი, რომელიც მოიცავს გამომავალი მასივის ელემენტებს, რისთვისაც გამოძახებები ხდება true.
- რუკა - შექმენით ახალი მასივი, რომელსაც დაემატება გამოძახების მნიშვნელობა.
- შემცირება - მასივის შემცირება ერთ მნიშვნელობამდე, ნომრით გამოძახება მასივის კანის ელემენტზე, დაწყებული პირველიდან (შეგვიძლია შევამციროთ მასივის ელემენტების ჯამი და სხვა ქვეჩანთა ფუნქციები).
- reduceRight - მუშაობს ანალოგიურად შემცირებაზე, მაგრამ იმეორებს ელემენტებს საპირისპირო თანმიმდევრობით.
2. for loop
კარგი ძველი წესებისთვის: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); )
Tim არანაკლებ, თანამედროვე JavaScript ძრავებში მსგავსი თამაშები ოპტიმიზაციით არაფერს ნიშნავს.
3. for...in loop-ის სწორი გამოყენება
მხოლოდ იმისთვის, რომ გაგახაროთ, რომ მოიგოთ for ... მარყუჟში, გახსოვდეთ, რომ მასივების გამეორება არ არის ის, რისთვისაც არის დავალებები. როგორც კი შეწყალება გაგრძელდება, for...in ციკლი ახარისხებს არა მასივის ინდექსს, არამედ ობიექტის ავტორიტეტის ხელახლა წყობას.ტიმი არ არის ნაკლები, ისეთ ვიპადკაში, როგორიცაა სხვადასხვა მასივების დახარისხება, რადგან ... in შეიძლება გამოჩნდეს ყავისფერი, რადგან ამის გაკეთება შესაძლებელია მხოლოდ ნებისმიერი სხვა ჩანაწერით, როგორც ეს ნაჩვენებია ქვემოთ მოცემულ კონდახში:
// a - მასივის გაფართოება var a =; a = "a"; a = "ბ"; a = "c"; for (var key in a) ( if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key<= 4294967294) {
console.log(a);
}
}
კანის გამეორების ამ ციკლისთვის, არსებობს ორი გადასინჯვა:
- ისეთები, რომლებზეც მასივს შეიძლება ჰქონდეს ძალა გასაღების სახელით (არ არის შემცირებული პირველი პროტოტიპიდან).
- ისინი, რომ გასაღები არის რიგი მთელი რიცხვის მეათე ჩანაწერის ჩასანაცვლებლად, რომლის მნიშვნელობა 4294967294-ზე ნაკლებია. დარჩენილი ნომრები აღებულია? მინიჭებული აქვს ES5 მასივის ინდექსს, რომელიც არის ყველაზე დიდი ინდექსი, რომელიც შეიძლება იყოს მასივის დედა ელემენტი: (2^32 - 2) = 4294967294 .
იმისათვის, რომ არ დაწეროთ ასეთი უხერხული კოდი კოდის გადასაწერად, თუ თქვენ გჭირდებათ მასივის ჩამოთვლა, შეგიძლიათ დაალაგოთ იგი მსგავსი ფუნქციით:
ფუნქცია arrayHasOwnIndex(მასივი, გასაღები) (დაბრუნება array.hasOwnProperty(გასაღები) && /^0$|^\d*$/.test(გასაღები) && გასაღები<= 4294967294;
}
შემდეგ ციკლის სხეული კონდახით მნიშვნელოვნად დააჩქარებს:
იყიდება (გასაღები a) (if (arrayHasOwnIndex(a, გასაღები)) (consol.log(a); ) )
გადასინჯვის კოდექსი უნივერსალურია, ყველა ხედვის მიმდებარედ. მაგრამ ახლის ნაცვლად, შეგიძლიათ დაამარცხოთ უფრო დიდი მოკლე ვერსია, თუმცა ფორმალურად არ ვიცი სწორი, პროტე, რომელიც შესაფერისია უფრო დიდი ვერსიისთვის:
იყიდება (გასაღები a) ( if (a.hasOwnProperty(გასაღები) && String(parseInt(გასაღები, 10)) === გასაღები) ( console.log(a); ) )
4. for... of loop (იმპლიციტურად განმეორებითი ცვლადი)
ES6, მიუხედავად იმისა, რომ ჯერ კიდევ აფერხებს შავი სტატუსს, დამნაშავეა იტერატორების JavaScript-ში დანერგვაში.იტერატორი
- ობიექტის მიერ პროტოკოლის განხორციელება, რომელიც განსაზღვრავს მნიშვნელობების თანმიმდევრობის მოხსნის სტანდარტულ მეთოდს (უსასრულო რაოდენობა).
Iterator - მთელი ობიექტი, რომელსაც აქვს მინიჭებული შემდეგი() მეთოდი - ფუნქცია არგუმენტების გარეშე, რომელიც აქცევს ობიექტს ორი ძალისგან:
- done (ლოგიკური) - იღებს მნიშვნელობას true, ისე, რომ იტერატორი მიაღწია გასამეორებელი მიმდევრობის ბოლოს. წინააღმდეგ შემთხვევაში, მნიშვნელობა შეიძლება იყოს ყალბი.
- value - ადგენს მნიშვნელობას, რადგან ის ბრუნავს იტერატორის მიერ. შესაძლებელია არ იყოს მინიჭებული (დღის განმავლობაში), რადგან შესრულებული ძალა შეიძლება იყოს ჭეშმარიტი.
ვიქტორიას აქცია ამისთვის...:
ვარვალი; var a = ["ა", "ბ", "გ"]; for (val of a) (console.log(val); )
ზედ გადატანისას, for...of მარყუჟი ირიბად უწოდებს Array ობიექტის იტერატორს მასივის კანის მნიშვნელობას.
5. აშკარად იტერატორის გამოყენებით
Iterators ასევე შეიძლება გადაუგრიხეს და ცალსახად, მართლაც, გარკვეულწილად კოდი ხდება არსებითად დასაკეცი, გასწორებული for... of loop-თან. ასე გამოიყურება:Var a = ["a", "b", "c"]; var it = a.entries(); var შესვლა; while (!(entry = it.next()). შესრულებულია) (consol.log(entry.value); )
ამ შემთხვევაში, Array.prototype.entries მეთოდი აქცევს იტერატორს, რომელიც გამოიყენება მასივის მნიშვნელობის საჩვენებლად. შესვლის.მნიშვნელობის კანის გამეორებაზე გადადის [გასაღები, მნიშვნელობა] ფორმის მასივი.
II. მასივის მსგავსი ობიექტების ჩამოთვლა
სწორი მასივების დანაშაული, JavaScript არის ასევე მასის მსგავსი ობიექტები . їх-ის რეალური მასივები ემთხვევა მათ, რომლებსაც სიმძლავრის სიგრძისა და სიმძლავრის სუნი აქვთ, ისეთი სახელებით, როგორიცაა რიცხვები, რომლებიც ემთხვევა მასივის ელემენტებს. მაგალითად, შეგიძლიათ დაასახელოთ DOM კოლექცია NodeList და არგუმენტების ფსევდო-მასივი, რომელიც ხელმისაწვდომია ფუნქციის/მეთოდის შუაში.1. უძრავი მასივების ჩამოთვლის მზაკვრული გზები
სულ ცოტა მეტი, მაგრამ არა ყველა მეთოდი საცნობარო მასივების ჩამოთვლისთვის შეიძლება შეჩერდეს მასივის მსგავსი ობიექტების ჩამოთვლისთვის.კონსტრუქციები for and for...in შეიძლება იყოს ეტაპობრივი მასივის მსგავს ობიექტებზე ზუსტად ისე, როგორც შესაბამისი მასივები.
ForEach და Array.prototype-ის სხვა მეთოდები ასევე მოითხოვს მასივის მსგავს ობიექტებს. რისთვისაც საჭიროა დააწკაპუნოთ Function.call ან Function.apply.
მაგალითად, თუ გსურთ თითოეულისთვის დააყენოთ Node ობიექტის childNodes-ის ავტორიტეტი, შეგიძლიათ გააკეთოთ ეს ასე:
Array.prototype.forEach.call(node.childNodes, function(child) ( // რაღაცის გაკეთება ბავშვის ობიექტთან));
შერჩევის გამეორების მოხერხებულობისთვის, შეგიძლიათ გამოიყენოთ Array.prototype.forEach მეთოდი okremіy zminnіy-სთვის და vikoristovuvat როგორც მოკლე:
// (თუ ვივარაუდებთ, რომ ქვემოთ მოცემული ყველა კოდი ერთსა და იმავე ფარგლებშია) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // მუშაობა ბავშვის ობიექტის გარშემო));
როგორც მასივის მსგავსი ობიექტი, როგორც იტერატორი, ის შეიძლება ცალსახად და იმპლიციტურად გადატრიალდეს ობიექტის ჩამოთვლისთვის ისევე, როგორც ეს არის საცნობარო მასივების შემთხვევაში.
2. საცნობარო მასივში გადაყვანა
ასევე არსებობს ერთი, კიდევ უფრო მარტივი გზა, რომ ჩამოვთვალოთ მასის მსგავსი ობიექტი: გადააკეთეთ იგი სწორ მასივად და აირჩიეთ ნებისმიერი სხვა გზა სწორი მასივების დასათვლელად. ტრანსფორმაციისთვის შეგიძლიათ გადაუგრიხოთ უნივერსალური მეთოდი Array.prototype.slice, რომელიც შეიძლება დამაგრდეს მასივის მსგავს ობიექტზე. ბრძოლა კიდევ უფრო ადვილია, როგორც ეს ნაჩვენებია ქვემოთ მოცემულ მაგალითში:Var trueArray = Array.prototype.slice.call(arrayLikeObject, 0);
მაგალითად, თუ გსურთ NodeList კოლექციის გადაყვანა საცნობარო მასივში, დაგჭირდებათ მსგავსი რამ:
Vardivs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
განახლება: როგორც rock and torbasow-ის კომენტარებშია ნათქვამი, ES6 Array.prototype.slice-ში შეიძლება შეცვალოს ორიგინალური Array.from მეთოდი.
3. საშუალო კლასის ობიექტების პატივისცემა
თუ Array.prototype მეთოდებს გარემოში არსებულ ობიექტებზე (როგორიცაა DOM კოლექციები) ამაგრებთ, მაშინ თქვენ ხართ პასუხისმგებელი იმაზე, რომ ამ მეთოდების სწორი მოქმედება არ არის გარანტირებული ყველა გარემოში (მათ შორის ბრაუზერებში). უმჯობესია კონკრეტული ობიექტის ქცევა კონკრეტულ გარემოში შევინახოთ, რაც უფრო ზუსტია იმის მხრივ, თუ რომელ ობიექტში ხორციელდება აბსტრაქტული ოპერაცია HasProperty. პრობლემა ის არის, რომ ES5 სტანდარტი იძლევა ოპერაციის დაწყებამდე ობიექტის სტანდარტულად არასწორი ქცევის შესაძლებლობას (დანაყოფი §8.6.2).აქედან გამომდინარე, მნიშვნელოვანია Array.prototype მეთოდების რობოტის ტესტირება კანის გარემოში (ბრაუზერი), რომელშიც დაგეგმილია თქვენი პროგრამის მუშაობა.
ვფიცავ ყველას, ვინც დაინტერესებულია ასეთი თემით, რადგან JavaScript მდიდარია მასივებით და დალაგებულია. მიმდინარე პუბლიკაციაში თემის ყველა დეტალს მივმართავ.
ამიტომ, სტატიის წაკითხვის შემდეგ, თქვენ გესმით, რომ ვებ დანამატებს აქვთ მდიდარი გამარჯვებული მასივები, როგორიცაა stinks იქმნება და როგორ შეიძლება მათი დახარისხება და დახარისხება. Დავიწყოთ!
როგორ იქმნება მდიდარი მასები და რა სურნელია ახლა საჭირო?
გამოიცანით ვარტო უკანა მხარეს, როგორ იქმნება დიდი ერთგანზომილებიანი მასივი.
მასივი =
და ახლა გახსოვდეთ, რომ მდიდარი მასივი არის მასიური მასივი.ველოდები, ტავტოლოგიას ჰგავს. პროტემ კიდევ ერთხელ წაიკითხა ქება. მართლაც, მდიდარი მასივი შედგება ახლის შენატანების რაოდენობით.
მოდით შევხედოთ ამ სიტუაციას. კობზე, რაც შეიძლება მალე, შეიყვანეთ საკუთარი სახელი, ხოლო სამუშაოს დასრულების შემდეგ ეკრანზე გამოჩნდება სარეიტინგო ცხრილი გრავიურებისა და ჩანაწერების სახელებით.
მივხვდი, რომ ასეთი ინფორმაცია გროვდება მონაცემთა ბაზაში. Ale თუ mi її vytyaguemo მონაცემთა ბაზიდან, otrimuemo მდიდარი მასივი. Aje კანის აპლიკაციაში დაზოგავს შესვლის სიმძიმეს და დაგროვილი ქულების რაოდენობას.
შეხედე ყველაფერს ასე:
var results = [["Markus", 333], ["Natasha", 211], ["Oleksiy", 124]];
ბაჩიტის მსგავსად, ინფორმაციის შენახვა შესაძლებელია სხვაგვარად. Tse შეიძლება იყოს რიგები, რიცხვები, ნავიტი. შესაძლებელია, რომ მასივები არ იყოს აკრეფილი.
ელემენტებზე გადასვლისას თქვენ ხვდებით ქვეოპერატორს.
მასალის კონსოლიდაციის მიზნით, გაანალიზეთ მცირე პროგრამა.
შედეგები =
საათობრივი დამუშავებისთვის რთული მონაცემების შეგროვებისთვის მასივი ხელით უნდა იყოს შევსებული. მანამდე კი მათთან მუშაობა უფრო მარტივად და ამავდროულად ტაძრის გაჭრა.
მონაცემთა დახარისხების გზები
JavaScript-i-ის მასივებისთვის, სახელის მეთოდი გადაეცემა დალაგება (). ეს ინსტრუმენტი ძალიან რბილია. მაშინვე აგიხსნით რატომ.
თუ მეთოდს პარამეტრების გარეშე აირჩევთ, ის ავტომატურად ახარისხებს მასივს პირველი ელემენტის მიხედვით ანბანური თანმიმდევრობით. ასე რომ, შაბათ-კვირის დროა შედეგები.დალაგება ()დასალაგებელი ობიექტი, ჩვენ შეგვიძლია დავინახოთ ღერძი ასე:
ოლექსია, 124
მარკუსი, 333
ნატაშა, 211
თუ გახსოვთ ელემენტებისა და ნაწილების დერმალურად დეპონირებული მასივის შესახებ, მაშინ ნახავთ:
124, ოლექსია
211, ნატაშა
333, მარკუსი
ამავდროულად, გასწორებისთვის, ტიმჩას ყველა ელემენტი გარდაიქმნება რიგებად.
თუ თქვენ გჭირდებათ ფუნქცია ელემენტების არასტანდარტულად დასალაგებლად, შეგიძლიათ თავად დაწეროთ და გადასცეთ პარამეტრად დალაგება (). რომელ ვარტოსთან ტყუილი, რა ფუნქცია აქვს კორისტუვაჩს მოქცევას:
- დადებითი რიცხვი (ძირითადად აირჩიეთ 1), რადგან პირველი ელემენტი მეორეს მიჰყვება ტოლობისას;
- უარყოფითი რიცხვი (ვთქვათ -1), თითქოს სხვა ელემენტი დამნაშავეა პირველის მიმდევრობაში;
- ნული, ისევე როგორც ორი მნიშვნელობა, რომლებიც შებრუნებულია, ტოლია.
Yak butt მოდით cob მასივი შედეგებიდალაგებულია სათვალეებისთვის. რატომ იქნება შეკვეთილი შედეგები უდიდესიდან ყველაზე პატარამდე. მისი განხორციელება შესაძლებელია ორი გზით.
პირველ ვარიანტში შევცვალე დახარისხების ლოგიკა, ტობტო. სიტუაციაში, თუ მჭირდება რიცხვის დადებითად გადაქცევა, მას უარყოფითად ვაქცევ საპირისპიროდ.
ჩანაწერების ცხრილი:
და ღერძი სხვაგვარად, დატოვა ლოგიკით დახარისხება, მაგრამ გამარჯვების ნაცვლად, დამატებითი მეთოდი - საპირისპირო (). როგორც სახელიდან ხედავთ, საპირისპირო ცვლის ელემენტების გადაცემის თანმიმდევრობას გახანგრძლივებამდე.
ასე რომ sort() ფუნქცია ასე გამოიყურება:
| 1 2 3 4 5 | ფუნქცია RecordSort(a, b) (თუ (a > b) დააბრუნებს 1; სხვა შემთხვევაში, თუ (a< b) return -1; else return 0; } |
ფუნქცია RecordSort(a, b) (თუ (a > b) დააბრუნებს 1; სხვა შემთხვევაში, თუ (a< b) return -1; else return 0; }
და შემდეგი ღერძი არის ინსტრუქციების უკეთესად დამატება.
Visnovok ხორციელდება ანალოგიურად.
მინდა ზვერნუტი პატივი მივაგოთ ერთ მნიშვნელოვან მომენტს. როდესაც vikoristanny tsikh funktsіy usі შეცვლა vіdbuvayutsya ერთად მასივი, რა თქვენ vikoristovuєte. ამ თანმიმდევრობით, რადგან თქვენ უნდა შეინახოთ მონაცემების cob ფორმა, გააკეთეთ ასლი და შემდეგ უკვე დაარედაქტირეთ.
კარგად, ღერძი I და rozpov_v მდიდარი მასივების და მათი დახარისხების შესახებ. თუ სტატიით დაჯილდოვდით, გამოიწერეთ ბლოგი და წაიკითხეთ სხვა პუბლიკაციები. მე ვიქნები vdyachny for reposts. Მალე გნახავ!
ბუუ!
პატივისცემით, რომან ჩუეშოვი
მასივი
მასივი- შეკვეთილია ღირებულებების შეგროვება. მასივის მნიშვნელობებს ელემენტებს უწოდებენ, ხოლო კანის ელემენტს ახასიათებს რიცხვითი პოზიცია მასივში, როგორც მას ინდექსი ეწოდება. JavaScript-ის მოძრაობებში მასივები უცვლელია: მასივის ელემენტები შეიძლება იყოს ნებისმიერი ტიპის დედა, ხოლო იმავე მასივის სხვადასხვა ელემენტი შეიძლება იყოს სხვადასხვა ტიპის დედა. მასივის ელემენტებს შეიძლება ეწოდოს ობიექტები ან სხვა მასივები, რომლებიც საშუალებას გაძლევთ შექმნათ მონაცემთა დასაკეცი სტრუქტურები, როგორიცაა ობიექტების მასივები და მასივების მასივები.
Move JavaScript მასივის ინდექსი იწყება ნულიდან და მათთვის გამოიყენება 32-ბიტიანი მთელი რიცხვები - მასივის პირველი ელემენტი შეიძლება იყოს ინდექსი 0. JavaScript მასივები დინამიურია: საჭიროების შემთხვევაში მათი გაზრდა და ზომის შეცვლა შესაძლებელია; არ არის საჭირო მასივების ხსოვნის ფიქსაციის დეკრიმინალიზაცია її svorennі chi მეხსიერების ხელახლა გავრცელება მათი remіrіv შეცვლისთვის.
მასივები JavaScript ენაზე - ობიექტების ფორმა განსაკუთრებულია და მასივების ინდექსები სამჯერ მეტს ნიშნავს, მხოლოდ ავტორიტეტების სახელები, ისევე როგორც მთელი რიცხვები.
მასივების შექმნა
უფრო ადვილია მასივის შექმნა დამატებითი ლიტერალისთვის, რომელიც არის კომით გამოყოფილი ელემენტების მარტივი სია კვადრატულ რკალებში. ლიტერატურულ მასივში მნიშვნელობები არ არის შეზღუდული ენის მუდმივებით - ისინი შეიძლება იყოს ვირაზი, მათ შორის ობიექტის ლიტერალები:
var ცარიელი =; // ცარიელი მასივი var ნომრები =; // 5 რიცხვითი ელემენტის მასივი var misc = [ 1.1, true, "a", ]; // სხვადასხვა ტიპის 3 ელემენტი + საბოლოო კომა ვარ ბაზა = 1024; var ცხრილი =; // მასივი ცვლილებებით var arrObj = [,]; // 2 მასივი შუაში ობიექტების შურისძიების მიზნით
მასივის ლიტერალური სინტაქსი საშუალებას გაძლევთ ჩასვათ ნეოენოვანი ფინალი ვინმესთვის, tobto. literal [,] ემთხვევა მასივს ორი ელემენტით, მაგრამ არა სამი.
მასივის შესაქმნელად საუკეთესო გზაა დიზაინერის ვიკის გამოყენება მასივი (). კონსტრუქტორთან დარეკვა შეიძლება განხორციელდეს სამი განსხვავებული გზით:
Clicky კონსტრუქტორი არგუმენტების გარეშე:
Var arr = new Array();
რა გზით შეიქმნება ლიტერალის ექვივალენტური ცარიელი მასივი.
Wiklicky კონსტრუქტორი რიცხვითი არგუმენტით, რომელიც იწყება ორმაგი მასივით:
vararr = NewArray(10);
და აქ შეიქმნება დანიშნული დოჟინის ცარიელი მასივი. Array() კონსტრუქტორის მოთხოვნის ასეთი ფორმა შეიძლება დაიშალოს მასივის მეხსიერების წინ, რათა დაინახოს ელემენტების რაოდენობა მანძილზე. პატივისცემის მისაცემად, რომ ამ შემთხვევაში მასივში იგივე მნიშვნელობები არ შეინახება.
მკაფიოდ მიუთითეთ კონსტრუქტორის ვიკიში პირველი ორი ან მეტი ელემენტის მნიშვნელობები მასივში, ან ერთი არა რიცხვითი ელემენტი:
Var arr = ახალი მასივი(5, 4, 3, 2, 1, "ტესტი");
და აქ კონსტრუქტორის არგუმენტები ხდება ახალი მასივის ელემენტების მნიშვნელობები. მასივის ლიტერალების არჩევანი შეიძლება იყოს უფრო მარტივი, უფრო დაბალი, როგორც Array() კონსტრუქტორი.
ელემენტების კითხვა და ჩაწერა მასივში
მასივის ელემენტებზე წვდომა დაცულია ოპერატორის დახმარებისთვის. Zliva vіd shackle შეიძლება გაიგზავნოს მასივში. მშვილდის შუა შეიძლება იყოს ცოტა მეტი ვირაზ, რაც ჩემთვის უცნობ მნიშვნელობას აქცევს. ეს სინტაქსი წაკითხვის მსგავსად შემთხვევითია, ამიტომ ელემენტის მნიშვნელობას ვწერ მასივში. ასევე, ვთქვათ, ყველა მინიშნება მოცემულია JavaScript-ის ინსტრუქციებით:
// შექმენით მასივი ერთი ელემენტით var arr = ["სამყარო"]; // ელემენტის წაკითხვა 0 var მნიშვნელობა = arr; // ელემენტის მნიშვნელობის ჩაწერა 1 arr = 3.14; // დაწერეთ მე-2 ელემენტის მნიშვნელობა i = 2; arr[i] = 3; // ჩაწერეთ ელემენტის მნიშვნელობა 3 arr = "hello" ; // წაიკითხეთ ელემენტი 0 და 2, ჩაწერეთ ელემენტი 3 arr] = arr;
ვვარაუდობ, რომ მასივები სპეციალიზირებულია სხვადასხვა ტიპის ობიექტებზე. კვადრატული რკალი, რომლებიც გამარჯვებულია მასივის ელემენტებზე წვდომისთვის, ისევეა, როგორც კვადრატული რკალი, რომელიც გამარჯვებულია ობიექტის ძალებზე წვდომისთვის. JavaScript თარჯიმანი გარდაქმნის რიცხვითი ინდექსების რკალებში ჩანაწერებს მწკრივად - ინდექსი 1 გარდაიქმნება მწკრივად "1" - და შემდეგ გამარჯვებულ რიგებს ავტორიტეტების სახელებად.
არაფერია განსაკუთრებული მწკრივში გადაყვანილი რიცხვითი ინდექსების შესახებ: ისინი თავად შეიძლება მუშაობდნენ ყველაზე მნიშვნელოვან ობიექტებთან:
var obj = (); // მარტივი ობიექტის შექმნა obj = "ერთი"; // ინდექსური იოგა მთელი რიცხვებით
მასივების თავისებურება ის არის, რომ სიმძლავრის სახელების მრავალფეროვნებით, ისევე როგორც არაუარყოფითი მთელი რიცხვებით, მასივი ავტომატურად ანიჭებს სიმძლავრის მნიშვნელობას. სიგრძე. მაგალითად, arr-ის მასივი შეიქმნა ერთი ელემენტით. მოდით მივცეთ მნიშვნელობები ელემენტებს 1, 2 და 3 ინდექსებით. ამ ოპერაციების შედეგად შეიცვალა მასივის სიგრძის სიმძლავრის მნიშვნელობა და გახდა 4-ის ტოლი.
Slid მკაფიოდ გადახედეთ მასივის ინდექსებს ობიექტების ავტორიტეტების სახელებში. Usі іndexi іnevі іn ძალაუფლება, არც ავტორიტეტის სიაში іnеmi, წარმოდგენილი მთელი რიცხვებით და ინდექსებით. ყველა მასივი არის ობიექტი და თქვენ შეგიძლიათ დაამატოთ ავტორიტეტი, მიუხედავად სახელებისა. თუმცა, მიუხედავად იმისა, რომ არსებობს ავტორიტეტები, თითქოს ისინი არიან მასივის ინდექსები, მასივები რეაგირებენ მნიშვნელობაზე, საჭიროების შემთხვევაში ავტორიტეტის სიგრძის მნიშვნელობების ჩათვლით.
გაითვალისწინეთ, რომ მასივების ინდექსის სახით ნებადართულია უარყოფითი და არა მთელი რიცხვების მოგება. ამგვარად, რიცხვები გარდაიქმნება რიგებად, როგორც გამარჯვებულები, როგორც ავტორიტეტების სახელები.
ამ წაშლილი ელემენტის დამატება მასივში
ჩვენ უკვე გავარკვიეთ, რომ ველების მასივში ელემენტების დამატების ყველაზე მარტივი გზა არის ახალი ინდექსებისთვის მნიშვნელობების მიცემა. მასივის ბოლოში ერთი ან მეტი ელემენტის დასამატებლად, შეგიძლიათ მოიგოთ მეთოდი ბიძგი ():
var arr=; // ცარიელი მასივის შექმნა arr.push("zero"); // დაამატეთ მნიშვნელობა end arr.push("one",2); // დაამატეთ კიდევ ორი მნიშვნელობა
თქვენ ასევე შეგიძლიათ დაამატოთ ელემენტი საბოლოო მასივში arr ელემენტის მნიშვნელობის მიცემით. მასივის კობზე ელემენტის ჩასასმელად შეგიძლიათ გამოიყენოთ ვიკორისტის მეთოდი unshift (), რომლის დროსაც მასივის ძირითადი ელემენტები გადაინაცვლებს პოზიციებზე უფრო მაღალი ინდექსებით.
თქვენ შეგიძლიათ იხილოთ მასივის ელემენტები წაშლის ოპერატორის დახმარებით, ობიექტების სიმძლავრის ნიშნად:
var arr=; წაშალე arr; 2 in arr; // false, მასივის ინდექსი 2 არ არის მინიჭებული arr.length; // 3: წაშლის ოპერატორი არ ცვლის სიგრძის მასივის სიმძლავრეს
ელემენტის ხილვადობა გამოცნობილია (თუმცა ზოგჯერ ჩანს) მას ენიჭება განუსაზღვრელი ელემენტის მნიშვნელობა. გახსოვდეთ, რომ წაშლის ოპერატორის მასივის ელემენტზე ჩაშვება არ ცვლის სიგრძის სიმძლავრის მნიშვნელობას და არ ჩამოაგდებს უფრო მაღალი ინდექსების მქონე ელემენტებს, ისე რომ ელემენტის წაშლის შემდეგ ის ცარიელი იტვირთება.
გარდა ამისა, შესაძლებელია ელემენტების დანახვა სასრულ მასივში, უბრალოდ სიმძლავრის სიგრძის ახალი მნიშვნელობის შემოღებით. მასივის მეთოდი pop()(push() მეთოდის საპირისპიროდ), რომელიც ცვლის წინა მასივს 1-ით და აბრუნებს ამოღებული ელემენტის მნიშვნელობას. ასევე მეთოდი shift ()(unshift() მეთოდის საპირისპიროდ), რომელიც არის ელემენტი, რომელიც ჩანს მასივის კობზე. წაშლის ოპერატორის ხედვით, shift() მეთოდი უბიძგებს ყველა ელემენტს ქვევით პოზიციამდე მათი მიმდინარე ინდექსის ქვემოთ.
ნარეშტი, მთავარი მდიდარი მეთოდი splice (), რომელიც საშუალებას გაძლევთ ჩასვათ, ნახოთ და შეცვალოთ მასივების ელემენტები. Vіn zmіnyuє znachennya znachivostі სიგრძე і zsuvaє elementi მასივი z ქვედა ან vysokim ინდექსები მსოფლიოში მოიხმარენ. ყველა ეს მეთოდი მიიღება ხელით.
Bagatovimіrnі masivi
JavaScript არ უჭერს მხარს "სწორ" მდიდარ მასივებს, მაგრამ საშუალებას აძლევს მათ ცუდად მიბაძოს დამატებითი მასივებისთვის. მასივების მასივში მონაცემთა ელემენტზე წვდომისთვის საკმარისია ორობითი ოპერატორის არჩევა.
მაგალითად, ვთქვათ, რომ მატრიცა შეიცვალა - ეს არის რიცხვების მასივის მასივი. კანის ელემენტის მატრიცა [x] არის რიცხვების მასივი. მასივების ერთ რაოდენობამდე წვდომისთვის, შეგიძლიათ გადაუგრიხოთ მატრიცა[x][y]. ქვემოთ მითითებულია კონკრეტული კონდახი, ორი სამყაროს მასივი გამრავლების ცხრილის მსგავსად გამარჯვებულია:
// უფრო მდიდარი მასივის შექმნა var ცხრილი = ახალი მასივი (10); // ცხრილს აქვს 10 მწკრივი for(var i = 0; i
Array კლასის მეთოდები
ECMAScript 3 სტანდარტი უზრუნველყოფს Array.prototype-ს უპიროვნო ფუნქციებს მასივებთან მუშაობისთვის, რომლებიც ხელმისაწვდომია როგორც მეთოდი და ნებისმიერი მასივი. ეს მეთოდები წარმოდგენილი იქნება მომავალ ჩვილებში.
join() მეთოდი
Array.join() მეთოდი გარდაქმნის მასივის ყველა ელემენტს მწკრივად, აერთიანებს მათ და აბრუნებს მწკრივს საჭიროებისამებრ. თქვენ შეგიძლიათ გადასცეთ მწკრივი არასავალდებულო არგუმენტის მეთოდს, რომელიც გამოყენებული იქნება მწკრივის ელემენტების შედეგის გასაძლიერებლად. ვინაიდან რიგი-rozdіlyuvach არ არის მითითებული, კომა არის გამარჯვებული. მაგალითად, შემდეგი ფრაგმენტი იწვევს სტრიქონს "1,2,3":
var arr=; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"
reverse() მეთოდი
Array.reverse() მეთოდი აბრუნებს მასივის ელემენტების თანმიმდევრობას შებრუნებით და აბრუნებს მასივის გადალაგებას. პერმუტაცია იმარჯვებს გარე მასივზე, tobto. ეს მეთოდი ქმნის ახალ მასივს ხელახალი დალაგების ელემენტებით და აწესრიგებს უკვე არსებულ მასივში. მაგალითად, შემდეგ ფრაგმენტში, reverse() და join() მეთოდები გაშიფრულია, რის შედეგადაც მიიღება სტრიქონი "3,2,1":
var arr=; arr.reverse().join(); // "3,2,1"
sort() მეთოდი
Array.sort() მეთოდი ახარისხებს მოცემული მასივის ელემენტებს და აბრუნებს დახარისხებულ მასივს. თუ sort() მეთოდი გამოძახებულია არგუმენტების გარეშე, ის დალაგებულია ანბანური თანმიმდევრობით (ელემენტების დასალაგებლად ისინი იცვლება რიგებად, რაც არ არის საჭირო). უმნიშვნელო ელემენტები გადადის მასივის ბოლოს.
ნებისმიერი სხვა თანმიმდევრობით დასალაგებლად, ანბანური თანმიმდევრობით, შეგიძლიათ sort() ფუნქცია არგუმენტად გადასცეთ sort() მეთოდს. ეს ფუნქცია დაყენებულია, ორი її არგუმენტიდან რომელი უნდა იყოს მემკვიდრეობით ადრე დახარისხებული სიიდან. ვინაიდან პირველი არგუმენტი შეიძლება ხელახლა მიენიჭოს მეორეს, ეკვივალენტობის ფუნქცია შეიძლება გადაეცეს უარყოფით რიცხვს. ვინაიდან პირველი არგუმენტი დამნაშავეა მეორეს დალაგებულ მასივში, ფუნქციას შეუძლია გადააქციოს ნულზე მეტი რიცხვი. და რადგან ეს ორი მნიშვნელობა ექვივალენტურია (მაშინ მათი თანმიმდევრობის თანმიმდევრობა არ არის მნიშვნელოვანი), გასწორების ფუნქცია პასუხისმგებელია 0-ის გადაქცევაზე:
var arr=; arr.sort(); // ანბანური თანმიმდევრობა: 1111, 222, 33, 4 arr.sort(function(a,b) ( // რიცხვითი თანმიმდევრობა: 4, 33, 222, 1111 return ab; // როტაციის მნიშვნელობა 0 // დალაგების თანმიმდევრობა a და ბ)); // დალაგება საპირისპირო მიმართულებით, უდიდესიდან პატარამდე arr.sort(function(a,b) (return b-a));
პატივისცემა, ამ ფრაგმენტის უსახელო ფუნქციის ოსტატურად მოგება. გათანაბრების ფუნქცია მხოლოდ აქ არის გამარჯვებული, არ არის საჭირო სახელის მიცემა.
concate() მეთოდი
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 ნაჭერი (0,3); // როტაცია arr.slice(3); // როტაცია arr.slice (1,-1); // Rotate arr.slice(-3,-2); // Მობრუნება
splice() მეთოდი
Array.splice() არის ზოგადი მეთოდი ელემენტების მასივში ჩასმის ან ამოსაღებად. slice() და concat() მეთოდების ხედვით, splice() მეთოდი ცვლის შეყვანის მასივს დაწკაპუნების რაოდენობის მიხედვით. გაფრთხილდით, რომ splice() და slice() მეთოდებს შეიძლება ჰქონდეთ მსგავსი სახელები, მაგრამ საკმაოდ განსხვავებული ოპერაციები.
splice() მეთოდს შეუძლია ამოიღოს ელემენტები მასივიდან, ჩასვას ახალი ელემენტები ან შეასრულოს შეტევითი ოპერაციები ღამით. მასივის ელემენტები, საჭიროების შემთხვევაში, გადაინაცვლებს ისე, რომ ჩასმის ან ამოღების შემდეგ შეიქმნა უწყვეტი თანმიმდევრობა.
splice() მეთოდის პირველი არგუმენტი დაყენებულია პოზიციაზე მასივში, დაწყებული იქიდან, სადაც ხდება ჩასმა და/ან წაშლა. კიდევ ერთი არგუმენტი აჩვენებს ელემენტების რაოდენობას, თითქოს მათი ამოღება (ვირიზანი) მასივიდან შეიძლებოდა. როგორც გამოტოვების კიდევ ერთი არგუმენტი, მასივის ყველა ელემენტი ჩანს ბოლომდე დანიშნულ მასივში. splice() მეთოდი აბრუნებს წაშლილი ელემენტების მასივს ან (რადგან სასურველი ელემენტი არ იყო ამოღებული) ცარიელი მასივი.
splice() მეთოდის პირველი ორი არგუმენტი ანიჭებს მასივის იმ ელემენტებს, რომლებიც უნდა ნახოთ. ამ არგუმენტების მიღმა შეიძლება იყოს რამდენიმე დამატებითი არგუმენტი, საწყისი ელემენტები, რომლებიც ჩასმული იქნება მასივში, დაწყებული პირველი არგუმენტისთვის მინიჭებული პოზიციიდან.
var arr=; arr.splice(4); // შემობრუნება, arr = arr.splice(1,2); // Turn , arr = arr.splice(1,1); // Მობრუნება; arr=arr=; arr.splice(2,0"a","b"); // Მობრუნება; arr=
push() და pop() მეთოდები
Push() და pop() მეთოდები საშუალებას გაძლევთ მოექცეთ მასივებს, როგორც სტეკები. push() მეთოდი ამატებს ერთ ან მეტ ახალ ელემენტს მასივის ბოლოს და აბრუნებს ახალს. pop() მეთოდი ასრულებს საპირისპირო ოპერაციას - ხედავს მასივის დარჩენილ ელემენტს, ცვლის წინა მასივის ელემენტს და აბრუნებს მის მნიშვნელობას. პატივი ეცით იმ ფაქტს, რომ ეს მეთოდები ცვლის არსებულ მასივს და არ ქმნის შეცვლილ ასლს.
unshift() და shift() მეთოდები
unshift() და shift() მეთოდები შეიძლება გაკეთდეს ისევე, როგორც push() და pop(), იმ გამონაკლისით, რომ ისინი ჩასვამენ და აშორებენ ელემენტებს მასივის კობზე და არა ბოლოს. unshift() მეთოდი ცვლის ინდექსისთვის დიდი ინდექსების არსებით ელემენტებს, ამატებს ელემენტს ან ელემენტს მასივს cob-ზე და აბრუნებს ახალ მასივს cob-ზე. shift() მეთოდი ხედავს და ატრიალებს მასივის პირველ ელემენტს, გადააქვს ყველა შემდეგი ელემენტი ერთი პოზიციით ქვემოთ, ისე, რომ იკავებს სივრცეს, რომელიც გადიოდა მასივის კობზე.
ბოლო განახლება: 04/09/2018
p align="justify"> მასივები აღიარებულია მონაცემთა ნაკრებებთან მუშაობისთვის. მასივის შესაქმნელად, zastosovuetsya new Array():
Var myArray = new Array();
ასევე არსებობს უფრო დიდი მოკლე გზა მასივის ინიციალიზაციისთვის:
Var myArray =;
ზოგჯერ ჩვენ ვქმნით ცარიელ მასივს. ალე, თქვენ ასევე შეგიძლიათ დაამატოთ ახალი Cob მონაცემები:
ვარ ხალხი = ["ტომი", "ალისა", "სემი"]; კონსოლის ჟურნალი (ხალხი);
ამ გზით myArray მასივში სამი ელემენტი იქნება. გრაფიკულად იოგა შეიძლება ასე იყოს ნაჩვენები:
ელემენტების რაოდენობამდე ინდექსაციისთვის, მასივი ინდექსირებული იქნება. ის იწყება ნულიდან, ამიტომ matime-ის პირველი ელემენტია ინდექსი 0, ხოლო დანარჩენი არის 2:
ვარ ხალხი = ["ტომი", "ალისა", "სემი"]; კონსოლის ჟურნალი (ხალხი); // Tom var person3 = ხალხი; // Sam console.log(person3); // სემ
თუ შევეცდებით ელემენტს დავუბრუნდეთ მასივის ზომაზე დიდი ინდექსით, მივიღებთ განუსაზღვრელს:
ვარ ხალხი = ["ტომი", "ალისა", "სემი"]; კონსოლის ჟურნალი (ხალხი); // განუსაზღვრელი
ასევე, ინდექსის შემდეგ, არის მითითებული მნიშვნელობა მასივის ელემენტებისთვის:
ვარ ხალხი = ["ტომი", "ალისა", "სემი"]; კონსოლის ჟურნალი (ხალხი); // ტომ ხალხი = "ბობ"; კონსოლის ჟურნალი (ხალხი); // ბობ
უფრო მეტიც, სხვა ენების თვალსაზრისით, როგორიცაა C# ან Java, შეგიძლიათ ჩადოთ ელემენტი, რომელიც თავიდანვე არ არის დაინსტალირებული:
ვარ ხალხი = ["ტომი", "ალისა", "სემი"]; კონსოლის ჟურნალი (ხალხი); // განუსაზღვრელი - მასივს აქვს სამზე მეტი ელემენტი ხალხი = "ბობ"; კონსოლის ჟურნალი (ხალხი); // ბობ
ასევე varto მიუთითებს, რომ JavaScript მასივები მკაცრად არ არის აკრეფილი vіdmіnu vіd low mov პროგრამირებაზე, ერთ მასივს შეუძლია შეინახოს ეს სხვადასხვა ტიპები:
Var ობიექტები = ["Tom", 12, true, 3.14, false]; კონსოლის ჟურნალი (ობიექტები);
გავრცელების ოპერატორი
გავრცელების ოპერატორი ... გაძლევთ საშუალებას აიღოთ მნიშვნელობა okremos-ის მასივიდან:
მოდით რიცხვები =; კონსოლის ჟურნალი (...ნომრები); // 1 2 3 4 console.log(ნომრები); //
გავრცელების ოპერატორი მითითებულია მასივის წინ. შედეგად, ... ნომრები გადააქცევს რიცხვების რაოდენობას, წინააღმდეგ შემთხვევაში ეს იქნება არა მასივი, არამედ თავად მნიშვნელობა.
Bagatovimіrnі masivi
მასივი შეიძლება იყოს ერთგანზომილებიანი და მდიდარი-მარტივი. მდიდარი მასივის კანის ელემენტი შეიძლება იყოს ჩარჩოში ჩასმული მასივით. უფრო ხშირად ვუყურებდით ერთგანზომილებიან მასივს, ახლა ვქმნით მდიდარ მასივს:
var numbers1 =; // ერთგანზომილებიანი მასივი var numbers2 = [,]; // ორ სამყაროს მასივი
ვიზუალურად, შეურაცხყოფის მასივი შეიძლება წარმოდგენილი იყოს შემდეგნაირად:
ცალმხრივი მასივის ნომრები1
მასივის პირველი ელემენტის ასაღებად, ასევე მოიგეთ ინდექსი:
Var tomInfo = ხალხი;
მხოლოდ ახლა შეიცვალა tomInfo არის წარმომადგენლობითი მასივი. იმისათვის, რომ ამოიღოთ წყობილი მასივის შუა ელემენტი, უნდა ავირჩიოთ ამ მეგობრის rozmіrnіst:
Console.log ("Im'ya:" + ხალხი); // Tom console.log ("Vik:" + ხალხი); // 25
იმისათვის, რომ ვიზუალურად წარმოვადგინოთ ორი სამყაროს მასივი ცხრილის ხედში, მაშინ ხალხის ელემენტი განთავსდება ცხრილის მწკრივზე, როგორც ეს იქნება პირველ რიგში და მეორე რიგში (პირველი მწკრივი - 0 - მწკრივი, სხვა - 1 - სვეტი).
ჩვენ ასევე შეგვიძლია მივანიჭოთ vikonati:
Var ხალხი = [["ტომი", 25, მცდარი], ["ბილი", 38, მართალია], ["ალისა", 21, მცდარი]]; ადამიანი = 56; // სხვა მნიშვნელობების მოწვევა Console.log(people); // 56 ადამიანი = ["ბობ", 29, ყალბი]; // მასივის მოწვევა console.log (ხალხი); // ბობ
მდიდარი მასივების შექმნით, ჩვენ არ ვართ გარშემორტყმული ორზე მეტი სამყაროთი, მაგრამ ასევე შეგვიძლია დიდი განზომილების ვიკორისტული მასივები:
var ნომრები =; რიცხვები =; // ახლა ნომრები არის ორი სამყაროს მასივი ნომრები =; // ახლა რიცხვები არის ტრივუმის მასივი ნომრები = 5; // triivity მასივის პირველი ელემენტია ძველი 5 console.log(numbers);