Ushbu darsda biz massivlar bilan tanishamiz, ularni qanday yaratishni, ularning elementlari ustida amallarni bajarishni o'rganamiz, shuningdek ular bilan ishlashda mavjud bo'lgan asosiy usullar va xususiyatlarni ko'rib chiqamiz.

JavaScript-da massiv nima?

Massiv bu buyurtma qilingan qiymatlar to'plami. Ushbu to'plamdagi qiymatlar elementlar deb ataladi. Massivdagi har bir element indeks deb ataladigan o'z seriya raqamiga (raqamiga) ega. Indekslar 0 dan boshlab raqamlanadi.

Quyidagi rasmda 5 ta elementdan iborat sonli massiv ko'rsatilgan. Ushbu massivning elementlari quyidagi ma'lumotlarni o'z ichiga oladi: 123 (indeks 0), 7 (indeks 1), 50 (indeks 2), -9 (indeks 3), 24 (indeks 4).

Massiv yaratish (e'lon qilish).

JavaScript-da massivlarni yaratish odatda yordamida amalga oshiriladi massiv harfi.

Massiv harfi vergul bilan ajratilgan elementlar ro'yxatini o'z ichiga olgan kvadrat qavslardan iborat.

Masalan:

Var empty = ; // bo'sh massiv var numbers = ; // raqamli massiv var arr = ; // har xil turdagi ma'lumotlarni o'z ichiga olgan massiv

JavaScript massividagi qiymatlar bir xil turdagi bo'lishi shart emas. Bular. Bitta massiv turli xil ma'lumotlarning qiymatlarini o'z ichiga olishi mumkin.

Muayyan massiv elementiga uning indeksi orqali kirish mumkin. Bu operatsiya indekslash operatsiyasi deb ham ataladi.

Masalan:

// 3 ta elementdan iborat massiv yaratish var smartphoneColors = ["Qora", "Oq", "Kulrang"]; // brauzer konsolida smartfonning Colors massivi elementlarining qiymatlarini 0 va 2 indekslari bilan ko'rsatish console.log("0 indeksli smartfonColors massivi elementining qiymati: " + smartphoneColors); // "0 indeksli smartfonColors massivi elementining qiymati: Qora" console.log("2-indeksli smartfonColors massivi elementining qiymati: " + smartphoneColors); // "0 indeksli smartfonColors massivi elementining qiymati: Kulrang" // 1 indeksli smartfonColors massivi elementining qiymatini "Qizil" smartfonga o'zgartiringColors = "Qizil"; // ["Qora", "Qizil", "Kulrang"] // 3 indeksli smartfonColors massiv elementini "Moviy" smartfon qiymatiga o'rnatingColors = "Ko'k"; // ["Qora", "Qizil", "Kulrang", "Ko'k"]

Massiv elementi qiymatlari sifatida nafaqat statik qiymatlardan, balki ifodalardan ham foydalanishingiz mumkin:

Var uzunlikA = 7, kengligiA = 5; var point = ;

Ob'ektlar massiv elementi qiymatlari sifatida ishlatilishi mumkin.

Var nuqtalari = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // 3 ta ob'ektdan iborat massiv

Massiv yaratishning yana bir usuli Array konstruktor funksiyasini chaqirishdan iborat.

Bo'sh massiv yaratish uchun argumentsiz konstruktor funksiyasi chaqiruvidan foydalaniladi.

Var empty = new Array(); // bo'sh massiv

Massiv yaratishning bu usuli literalga teng.

Agar siz konstruktor funksiyasiga argument sifatida raqamni ko'rsatsangiz, u ko'rsatilgan elementlar sonidan iborat massivni yaratadi. Bundan tashqari, bu elementlarning barchasi ularning qiymati sifatida aniqlanmagan bo'ladi.

Var arr = yangi massiv(5); // 5 ta elementdan iborat massiv (element qiymatlari aniqlanmagan)

Qavslar ichidagi konstruktor funksiyasiga bir nechta qiymat yoki bitta raqamli bo'lmagan qiymat o'tkazilsa, u unga berilgan argumentlardan massiv hosil qiladi.

Ko'pgina boshqa dasturlash tillaridan farqli o'laroq, JavaScript-dagi massivlar o'z hajmini avtomatik ravishda o'zgartiradi, ya'ni. ular tabiatan dinamikdir. Bunday massivlarga hech qanday o'lchamlar berilishi shart emas. JavaScript massivlarining yana bir o‘ziga xos xususiyati shundaki, bir massivning turli elementlarida har xil turdagi ma’lumotlar bo‘lishi mumkin.

uzunlik xususiyati (massiv uzunligi)

Massiv uzunligini (elementlar sonini) aniqlash length xossasi yordamida amalga oshiriladi.

//Array funksiyasidagi elementlarning qiymatlarini sanab massiv yarating var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //lengthArray o'zgaruvchisini volumeHDDs massivi uzunligiga belgilash var lengthArray = volumeHDDs.length;

Massivning birinchi elementini qanday olish mumkin

Massivning birinchi elementining qiymatini olish ushbu massivning kvadrat qavs ichida 0 raqamini ko'rsatish orqali amalga oshiriladi:

//3 elementdan iborat massiv yaratish var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //massivning birinchi elementi qiymatini olish var firstValue = volumeHDDs;

Massivning oxirgi elementini qanday olish mumkin

Massivning oxirgi elementining qiymati ushbu massivning kvadrat qavs ichida array_name.length-1 ifodasini ko'rsatish orqali olinadi:

//3 elementdan iborat massiv yaratish var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //massivning oxirgi elementi qiymatini olish var lastValue = volumeHDDs;

Massiv ustida takrorlash

Massiv elementlarini takrorlash for tsikli yordamida amalga oshiriladi.

Masalan, massivning barcha elementlarini takrorlaymiz va ularning qiymatlarini brauzer konsolida ko'rsatamiz (F12):

//massiv yaratish nameStudents, 4 elementdan iborat var nameStudents = new Array("Petya","Vasya","Kolya","Maksim"); //massiv elementlarini 0 dan massiv uzunligi-1 gacha (var i=0; i) uchun takrorlash<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

O'chirish operatorining maqsadi nima?

Delete operatori massivdan elementni olib tashlash uchun emas, balki berilgan massiv elementiga aniqlanmagan qiymatni belgilash uchun ishlatiladi.

Var namePlanets = new Array("Venera", "Merkuriy", "Yer", "Mars"); Planets nomini o'chirish; uchun (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Massivlar bilan ishlash funksiyalari (massiv obyekti usullari)

Array obyekti massivlar bilan ishlashning quyidagi usullarini (funksiyalarini) o‘z ichiga oladi:

• siljish
• siljitish
• tilim
• qo'shish
• Split
• teskari

Push usuli (massiv oxiriga element qo'shish)

Surish usuli massiv oxiriga element qo'shish uchun mo'ljallangan. Ushbu elementning qiymati ushbu usul uchun parametr sifatida belgilanadi. Natijada, push usuli qo'shilgan narsalarni hisobga olgan holda massivdagi elementlar sonini qaytaradi.

Var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars"]; namePlanets.push("Yupiter"); // 5 console.log(namePlanets); // ["Venera", "Merkuriy", "Yer", "Mars", "Yupiter"]

pop usuli (massivdan oxirgi elementni olib tashlash)

Pop usuli massivdan oxirgi elementni olib tashlash uchun mo'ljallangan. Ushbu usul hech qanday parametrga ega emas. Natijada, u massivning oxirgi (olib tashlangan) elementining qiymatini qaytaradi.

Var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars"]; namePlanets.pop(); // "Mars" console.log(namePlanets); // ["Venera", "Merkuriy", "Yer"]

Shift usuli (massivdan birinchi elementni olib tashlash)

Shift usuli massivdan birinchi elementni olib tashlash uchun mo'ljallangan, ya'ni. indeks 0 ga ega element. Massivning barcha boshqa elementlari boshiga o'tkaziladi, ya'ni. ularning har biri uchun indeks 1 ga kamayadi. Bu usul natijasida olib tashlangan elementning qiymatini qaytaradi.

Var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars"]; namePlanets.shift(); // "Venera" console.log(namePlanets); // ["Merkuriy", "Yer", "Mars"]

unshift usuli (massiv boshiga element qo'shish)

Unshift usuli massiv boshiga (boshqa elementlardan oldin) element qo‘shish uchun mo‘ljallangan. Ushbu elementning qiymati ushbu usul uchun parametr sifatida belgilanadi. Natijada, bu usul qo'shilgan narsalarni hisobga olgan holda massivdagi elementlar sonini qaytaradi.

Var namePlanets = ["Merkuriy", "Yer", "Mars", "Yupiter"]; namePlanets.unshift("Venera"); // 5 console.log(namePlanets); // ["Venera", "Merkuriy", "Yer", "Mars", "Yupiter"]

tilim usuli (massivning bir qismini nusxalash)

Slice usuli massivning bir qismini nusxalash uchun mo'ljallangan. Biroq, u asl massivni o'zgartirmaydi, lekin natijada tanlangan elementlardan iborat yangi massivni qaytaradi.

Dilim usuli 2 parametrga ega:

• 1 parametr (majburiy) - elementlardan nusxa ko'chirishni boshlash kerak bo'lgan element indeksini ko'rsatish uchun mo'ljallangan;
• 2-parametr (ixtiyoriy) - nusxa ko'chirish kerak bo'lgan element indeksini ko'rsatish uchun mo'ljallangan (bu holda u yangi massivga kiritilmaydi). Agar siz uni ko'rsatmasangiz, unda ko'rsatilgan massivning oxirigacha bo'lgan elementlar ko'chiriladi.

var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars", "Yupiter"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Yer", "Mars"]

Splice usuli (massiv tarkibini o'zgartirish)

Splice usuli massiv tarkibini o'zgartirish uchun mo'ljallangan. Undan massivga elementlar qo'shish va ularni olib tashlash uchun ham foydalanish mumkin.

Splice usulining sintaksisi:

Array.splice(startIndex, deleteCount [, element1[, element2[, ...]]]); /* startIndex (majburiy) - massivni o'zgartirishni boshlash uchun elementning boshlang'ich indeksi. Agar siz massiv uzunligidan kattaroq raqamni startIndex sifatida belgilasangiz, boshlang'ich indeksi massiv oxiriga o'rnatiladi. Agar startIndex sifatida manfiy raqamni belgilasangiz, boshlang'ich element oxiridan boshlab hisoblanadi. deleteCount (majburiy) - massivdan qancha elementlarni o'chirish kerakligini ko'rsatadigan raqam. Agar elementlarni massivdan o'chirish kerak bo'lmasa, deleteCount 0 ga o'rnatilishi kerak. Shundan so'ng siz massivga qo'shiladigan kamida bitta yangi elementni belgilashingiz kerak. Agar siz startIndex dan boshlab massivdagi qolgan elementlar sonidan oshib ketadigan deleteCount sifatida raqamni belgilasangiz, u holda ular baribir o'chiriladi (ya'ni, boshlang'ich indeksidan boshlab massiv oxirigacha bo'lgan barcha elementlar). element1, element2, .. (ixtiyoriy) - massivga qo'shilishi kerak bo'lgan elementlar. */

Splice usulidan foydalanishga misollar.

Bir qatordan ba'zi elementlarni olib tashlash uchun splice usulidan foydalanish.

Var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars"]; namePlanets.splice(2, 2); //["Yer", "Mars"] console.log(namePlanets); // ["Venera", "Merkuriy"]

Bir qatordan elementni olib tashlash va unga yangilarini qo'shish uchun qo'shish usulidan foydalanish.

Var namePlanets = ["Venera", "Merkuriy", "Yer", "Mars"]; namePlanets.splice(1, 1, "Uran", "Neptun", "Saturn"); // ["Merkuriy"] console.log(namePlanets); // ["Venera", "Uran", "Neptun", "Saturn", "Yer", "Mars"]

Splice usulidan faqat massivga yangi elementlar qo'shish uchun foydalanish.

Var namePlanets = ["Yupiter", "Saturn", "Uran"]; namePlanets.splice(0, 0, "Venera", "Merkuriy", "Yer", "Mars"); // console.log(namePlanets); // ["Venera", "Merkuriy", "Yer", "Mars", "Yupiter", "Saturn", "Uran"]

qo'shilish usuli (massivni satrga aylantirish)

Birlashtirish usuli massivning barcha elementlarini satrga birlashtirish uchun mo'ljallangan.

Qo'shilish usuli sintaksisi:

Array.join(); /* ajratuvchi (ixtiyoriy) - har bir massiv elementi orasidagi bog'lovchi qator sifatida ishlatiladigan ajratuvchi. Agar ushbu parametr belgilanmagan bo'lsa, "," ulanish qatori sifatida ishlatiladi. Agar siz bo'sh qatorni parametr sifatida belgilasangiz, qaytarilgan qatordagi massiv elementlari hech narsa bilan ajratilmaydi */

Var rezavorlar = ["Uzum", "Uzum", "Smorodina", "Atirgul kestirib"]; var berriesStr1 = berries.join(); // "Uzum, uzum, smorodina, atirgullar" var berriesStr2 = berries.join(""); // "GrapesGrapesCurrantRosehip" var berriesStr3 = berries.join(", "); // "Uzum, uzum, smorodina, atirgul" var berriesStr4 = berries.join(" + "); // "Uzum + uzum + smorodina + atirgul kestirib"

Agar siz ajratuvchi sifatida qatordan foydalansangiz, u satrga aylantiriladi.

Var rezavorlar = ["Uzum", "Uzum", "Smorodina", "Atirgul kestirib"]; var berriesStr1 = berries.join(false); // "GrapesfalseGrapesfalseCurrantfalseRosehip" var berriesStr2 = berries.join(4/2); // "Grapes2Grapes2Currant2Rose Hip" Null yoki qiymat sifatida aniqlanmagan massiv elementlari bo'sh satrga o'tkaziladi. var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"

Satrni massivga aylantirish - bo'linish

Split usuli satrni massivga aylantirish uchun mo'ljallangan. Bu usul bitta parametrga ega bo'lib, unga ko'ra satrni belgilashingiz mumkin, uning asosida bu satr qatorlar qatoriga bo'linadi.

Var strElementComputers = "Tizim bloki, monitor, klaviatura, sichqoncha, dinamiklar, printer"; var elementComputers = strElementComputers.split(", "); console.log("Masivdagi elementlar soni: " + elementComputers.length); uchun (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Massiv elementlarini teskari tartibda qayta tartiblash - teskari

Teskari usul massiv elementlarini teskari tartibda qayta tartiblash uchun mo'ljallangan.

Var namePlanets = new Array("Venera", "Merkuriy", "Yer", "Mars"); namePlanets.reverse(); console.log("Masivdagi elementlar soni: " + namePlanets.length); uchun (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Massiv elementlarini saralash - tartiblash

Tartiblash usuli massiv elementlarini saralash uchun ishlatiladi. Odatiy bo'lib, bu usul massivni satrlar sifatida tartiblaydi.

Var namePlanets = new Array("Venera", "Merkuriy", "Yer", "Mars"); namePlanets.sort(); console.log("Masivdagi elementlar soni: " + namePlanets.length); uchun (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

21.06.2017 12:17 da

JavaScript-da obyektlar massivi hajmini hisoblash uchun massivning length xususiyatidan foydalaning.

Var arr = ["birinchi", "ikkinchi"]; console.log(arr.length); // 2

Javascriptdagi massivlarda etishmayotgan indekslar bo'lishi mumkin. Masalan

Var arr = ; arr = "birinchi"; arr = "ikkinchi";

Uzunlik xususiyati massivning maksimal indeksini qaytaradi + 1. ya'ni. berilgan misolda uzunlik = 5.

Javascriptda massivdagi elementlar sonini hisoblash

Array.prototype.count = function())( var result = 0; for(var i = 0; i)< this.length; i++) if (this[i] != undefined) result++; return result; }

Foydalanish misoli

Var arr = ; arr = "birinchi"; arr = "ikkinchi"; console.log(arr.count()); //2

Uzunlik xususiyatiga qiymat ham belgilashingiz mumkin. Bu mavjud massiv uzunligini qisqartirish imkonini beradi.

Var arr = ["birinchi", "ikkinchi", "uchinchi"]; arr.length = 2; console.log(arr); // ["birinchi", "ikkinchi"]

Javascriptda massiv hajmini baytlarda hisoblash

Massivlar oddiy ob'ektlardir, shuning uchun massiv hajmini baytlarda hisoblash boshqa ob'ektlarning o'lchamini hisoblashdan farq qilmaydi. Afsuski, javascript o'lchamni hisoblash uchun API taqdim etmaydi, shuning uchun uni o'zingiz hisoblashingiz kerak bo'ladi. Bu quyidagicha amalga oshiriladi: biz ob'ektning barcha xususiyatlarini ko'rib chiqamiz; agar xususiyat ibtidoiy turdagi bo'lsa, umumiy natijaga ushbu turdagi misol hajmini qo'shamiz; agar xususiyat ob'ektni o'z ichiga olsa, biz rekursiv hisoblaymiz. uning hajmi.

Function sizeOf(obj) ( var bytes = 0; if(obj !== null && obj !== undefined) ( switch(typeof obj) ( case "number": bayt += 8; break; case "string": baytlar += obj.length * 2; break; case "boolean": bayt += 4; break; case "object": for(var key in obj) ( baytlar += sizeOf(obj); ) break; ) ) qaytariladigan baytlar ;);

Usul to'g'ri emas va juda ko'p muammolarga ega - masalan, cheksiz tsiklga o'tish imkoniyati mavjud.

Oxirgi yangilanish: 26.03.2018

Array obyekti massivni ifodalaydi va biz massivni boshqarishimiz mumkin bo‘lgan bir qancha xususiyatlar va usullarni taqdim etadi.

Massivni ishga tushirish

Kvadrat qavslar yoki Array konstruktori yordamida bo'sh massiv yaratishingiz mumkin:

Var foydalanuvchilari = new Array(); var people = ; console.log(foydalanuvchilar); // Massiv console.log(odamlar); //Masiv

Siz darhol ma'lum miqdordagi elementlarga ega massivni ishga tushirishingiz mumkin:

Var foydalanuvchilari = new Array("Tom", "Bill", "Alis"); var people = ["Sam", "Jon", "Kate"]; console.log(foydalanuvchilar); // ["Tom", "Bill", "Alis"] console.log(odamlar); // ["Sem", "Jon", "Keyt"]

Siz massivni belgilashingiz va unga yangi elementlar qo'shishingiz mumkin:

Var foydalanuvchilari = new Array(); foydalanuvchilar = "Tom"; foydalanuvchilar = "Kate"; console.log(foydalanuvchilar); // "Tom" console.log(foydalanuvchilar); // aniqlanmagan

Sukut bo'yicha massiv nol uzunlik bilan yaratilganligi muhim emas. Indekslardan foydalanib, biz massivdagi u yoki bu elementni ma'lum bir indeksda almashtirishimiz mumkin.

uzunligi

Massiv uzunligini bilish uchun length xususiyatidan foydalaning:

Var fruit = new Array(); meva = "olma"; meva = "nok"; meva = "olxo'ri"; document.write("Meva massivida" + fruit.length + " element:
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Aslida, massivning uzunligi oxirgi elementning indeksi plyus bitta bo'ladi. Masalan:

Var foydalanuvchilari = new Array(); // massivda 0 ta element mavjud users = "Tom"; foydalanuvchilar = "Kate"; foydalanuvchilar = "Sam"; for(var i=0; i

Brauzer chiqishi:

Tom Kate aniqlanmagan, aniqlanmagan Sem

Biz 2 va 3 indekslari uchun elementlarni qo'shmaganimizga qaramay, bu holda massiv uzunligi 5 raqami bo'ladi. 2 va 3 indekslari bo'lgan elementlar aniqlanmagan qiymatga ega bo'ladi.

Massivdan nusxa olish. tilim()

Massivdan nusxa olish sayoz yoki sayoz (sayoz nusxa) va chuqur (chuqur nusxa) bo'lishi mumkin.

Sayoz nusxa ko'chirish uchun o'zgaruvchiga massivni saqlaydigan boshqa o'zgaruvchining qiymatini belgilash kifoya:

Var foydalanuvchilari = ["Tom", "Sam", "Bill"]; console.log(foydalanuvchilar); // ["Tom", "Sam", "Bill"] var odamlar = foydalanuvchilar; // sayoz nusxa ko'chiruvchi odamlar = "Mayk"; // ikkinchi elementni o'zgartirish console.log(users); // ["Tom", "Mayk", "Bill"]

Bunday holda, odamlar o'zgaruvchisi nusxalangandan so'ng, foydalanuvchi o'zgaruvchisi bilan bir xil massivga ishora qiladi. Shuning uchun, odamlardagi elementlarni o'zgartirganda, foydalanuvchilardagi elementlar ham o'zgaradi, chunki aslida u bir xil massivdir.

Bunday xatti-harakatlar har doim ham istalmagan. Misol uchun, biz o'zgaruvchilar nusxa ko'chirishdan keyin alohida massivlarga ishora qilishini xohlaymiz. Va bu holda, slice() usuli yordamida chuqur nusxa ko'chirishdan foydalanishingiz mumkin:

Var foydalanuvchilari = ["Tom", "Sam", "Bill"]; console.log(foydalanuvchilar); // ["Tom", "Sam", "Bill"] var people = users.slice(); // chuqur nusxa odamlar = "Mayk"; // ikkinchi elementni o'zgartirish console.log(users); // ["Tom", "Sam", "Bill"] console.log(odamlar); // ["Tom", "Mayk", "Bill"]

Bunday holda, nusxa ko'chirilgandan so'ng, o'zgaruvchilar turli massivlarga ishora qiladi va biz ularni bir-biridan alohida o'zgartirishimiz mumkin.

slice() usuli ham massivning bir qismini nusxalash imkonini beradi:

Var foydalanuvchilari = ["Tom", "Sam", "Bill", "Alis", "Keyt"]; var people = users.slice(1, 4); console.log(odamlar); // ["Sem", "Bill", "Elis"]

slice() usuli massivdan qiymatlarni olish uchun ishlatiladigan boshlang'ich va yakuniy indekslarni o'tkazadi. Ya'ni, bu holda, yangi massivga tanlash, shu jumladan emas, 1 indeksdan 4 indeksga o'tadi. Massivni indekslash noldan boshlangani uchun yangi massiv ikkinchi, uchinchi va to‘rtinchi elementlarni o‘z ichiga oladi.

Durang()

Push() usuli elementni massiv oxiriga qo'shadi:

Var meva =; fruit.push("olma"); fruit.push("nok"); fruit.push("olxo'ri"); meva.push("gilos","o'rik
"); document.write(meva); // olma, nok, olxo'ri, olcha, o'rik

pop()

pop() usuli massivdan oxirgi elementni olib tashlaydi:

Var meva = ["olma", "nok", "olxo'ri"]; var lastFruit = fruit.pop(); // document.write(lastFruit +" massividan oxirgi elementni chiqarib oling
"); document.write("Meva massivida" + fruit.length + " element:
"); for(var i=0; i ");

Brauzer chiqishi:

Olxo'ri Meva qatorida 2 ta element mavjud: olma noklari

shift()

Shift() usuli birinchi elementni massivdan oladi va olib tashlaydi:

Var meva = ["olma", "nok", "olxo'ri"]; var firstFruit = fruit.shift(); document.write(firstFruit + "
"); document.write("Meva massivida" + fruit.length + " element:
"); for(var i=0; i ");

Brauzer chiqishi:

Olma Meva massivida 2 ta element mavjud: nok olxo'ri

unshift()

unshift() usuli massiv boshiga yangi element qo'shadi:

Var meva = ["olma", "nok", "olxo'ri"]; fruit.unshift("o'rik"); hujjat.yozish(meva);

Brauzer chiqishi:

O'rik, olma, nok, olxo'ri

Indeks bo'yicha elementni olib tashlash. splice()

Splice() usuli ma'lum bir indeksdagi elementlarni olib tashlaydi. Masalan, uchinchi indeksdan elementlarni olib tashlash:

Var foydalanuvchilari = ["Tom", "Sam", "Bill", "Alis", "Keyt"]; var o'chirildi = users.splice(3); console.log(o'chirilgan); // [ "Alis", "Kate" ] console.log(foydalanuvchilar); // [ "Tom", "Sem", "Bill" ]

Slice usuli olib tashlangan elementlarni qaytaradi.

Bunday holda, o'chirish massivning boshidan sodir bo'ladi. Agar siz salbiy indeksdan o'tsangiz, o'chirish massiv oxiridan amalga oshiriladi. Masalan, oxirgi elementni olib tashlaymiz:

Var foydalanuvchilari = ["Tom", "Sam", "Bill", "Alis", "Keyt"]; var o'chirildi = users.splice(-1); console.log(o'chirilgan); // [ "Kate" ] console.log(foydalanuvchilar); // [ "Tom", "Sem", "Bill", "Elis" ]

Usulning qo'shimcha versiyasi o'chirish uchun tugatish indeksini belgilash imkonini beradi. Masalan, birinchidan uchinchi indeksni o'chirib tashlaylik:

Var foydalanuvchilari = ["Tom", "Sam", "Bill", "Alis", "Keyt"]; var o'chirildi = users.splice(1,3); console.log(o'chirilgan); // [ "Sam", "Bill", "Alis" ] console.log(foydalanuvchilar); // [ "Tom", "Keyt" ]

Splice usulining yana bir versiyasi o'chirilgan elementlar o'rniga yangi elementlarni kiritish imkonini beradi:

Var foydalanuvchilari = ["Tom", "Sam", "Bill", "Alis", "Keyt"]; var deleted = users.splice(1,3, "Ann", "Bob"); console.log(o'chirilgan); // [ "Sam", "Bill", "Alis" ] console.log(foydalanuvchilar); // [ "Tom", "Enn", "Bob", "Keyt" ]

Bunday holda, biz 1-dan 3-chi indekslardan uchta elementni o'chirib tashlaymiz va o'rniga ikkita elementni kiritamiz.

concat()

Massivlarni birlashtirish uchun concat() usuli qo'llaniladi:

Var meva = ["olma", "nok", "olxo'ri"]; var sabzavotlar = ["pomidor", "bodring", "kartoshka"]; var mahsulotlar = fruit.concat(sabzavot); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

Bunday holda, faqat bir xil turdagi massivlarni birlashtirish shart emas. Turli xil turlari mumkin:

Var meva = ["olma", "nok", "olxo'ri"]; var narxlar =; var mahsulotlar = fruit.concat(narxlar);

qo'shilish()

join() usuli massivning barcha elementlarini bitta satrga birlashtiradi:

Var meva = ["olma", "nok", "olxo'ri", "o'rik", "shaftoli"]; var fruitString = fruit.join(", "); document.write(fruitString);

join() usuli massiv elementlari orasidagi ajratuvchidan o'tkaziladi. Bunday holda, ajratuvchi sifatida vergul va bo'sh joy (", ") qo'llaniladi.

sort()

sort() usuli massivni o'sish tartibida tartiblaydi:

Var meva = ["olma", "nok", "olxo'ri", "o'rik", "shaftoli"]; fruit.sort(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Brauzer chiqishi:

O'rik nok shaftoli olxo'ri olma

teskari()

Reverse() usuli massivni orqaga qaytaradi:

Var meva = ["olma", "nok", "olxo'ri", "o'rik", "shaftoli"]; fruit.reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Brauzer chiqishi:

Shaftoli o'rik olxo'ri nok olma

Sort() usuli bilan birgalikda siz massivni kamayish tartibida saralashingiz mumkin:

Var meva = ["olma", "nok", "olxo'ri", "o'rik", "shaftoli"]; fruit.sort().reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Brauzer chiqishi:

Olma olxo'ri shaftoli nok o'rik

Element indeksini topish

indexOf() va lastIndexOf() usullari elementning massivga birinchi va oxirgi kiritilishi indeksini qaytaradi. Masalan:

Var meva = ["olma", "nok", "olxo'ri", "olma", "nok"]; var firstIndex = fruit.indexOf("olma"); var lastIndex = fruit.lastIndexOf("olma"); var otherIndex = fruit.indexOf("gilos"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 hujjat.write(otherIndex); // -1

firstIndex 0 qiymatiga ega, chunki massivdagi "olma" qatorining birinchi qo'shilishi 0 indeksida, oxirgisi esa 3 indeksida.

Agar element massivda bo'lmasa, bu holda indexOf() va lastIndexOf() usullari -1 qiymatini qaytaradi.

har bir()

Every() usuli barcha elementlarning ma'lum bir shartga mos kelishini tekshiradi:

Var raqamlari = [ 1, -12, 8, -4, 25, 42 ]; funktsiya sharti (qiymat, indeks, massiv) ( var natija = noto'g'ri; if (qiymat > 0) ( natija = rost; ) natijani qaytarish; ); var passed = raqamlar.har bir (shart); hujjat.yozmoq(o'tgan); // yolg'on

Every() usuli shartni parametr sifatida ifodalovchi funksiyadan o'tadi. Ushbu funktsiya uchta parametrni oladi:

Funktsiya sharti (qiymat, indeks, massiv) ( )

Qiymat parametri takrorlanayotgan joriy massiv elementini, indeks parametri ushbu element indeksini ifodalaydi va massiv parametri massivga havolani uzatadi.

Ushbu funktsiyada biz o'tkazilgan element qiymatini ba'zi shartlarga muvofiqligini tekshirishimiz mumkin. Misol uchun, ushbu misolda biz massivning har bir elementini uning noldan katta yoki yo'qligini tekshiramiz. Agar u kattaroq bo'lsa, biz qiymatni qaytaramiz true , ya'ni element shartga javob beradi. Agar kamroq bo'lsa, unda false qaytariladi - element shartga javob bermaydi.

Natijada, numbers.every(shart) usuli chaqirilganda, u raqamlar massivining barcha elementlarini takrorlaydi va ularni birma-bir shart funksiyasiga uzatadi. Agar bu funksiya barcha elementlar uchun true qiymatini qaytarsa, every() usuli rost qiymatini qaytaradi. Agar kamida bitta element shartga mos kelmasa, every() usuli false ni qaytaradi.

biroz()

Some() usuli every() usuliga o'xshaydi, faqat u kamida bitta element shartga mos kelishini tekshiradi. Va bu holda, some() usuli true ni qaytaradi. Agar massivda shartga mos keladigan elementlar bo'lmasa, false qaytariladi:

Var raqamlari = [ 1, -12, 8, -4, 25, 42 ]; funktsiya sharti (qiymat, indeks, massiv) ( var natija = noto'g'ri; agar (qiymat === 8) ( natija = rost; ) natijani qaytarish; ); var passed = raqamlar.ba'zi (shart); // rost

filtr()

filter() usuli, some() va every() kabi, shart funksiyasini qabul qiladi. Shu bilan birga, u ushbu shartga javob beradigan elementlarning qatorini qaytaradi:

Var raqamlari = [ 1, -12, 8, -4, 25, 42 ]; funktsiya sharti (qiymat, indeks, massiv) ( var natija = noto'g'ri; if (qiymat > 0) ( natija = rost; ) natijani qaytarish; ); var filteredNumbers = raqamlar.filtr(shart); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

Brauzer chiqishi:

1 8 25 42

forEach() va map()

ForEach() va map() usullari elementlar ustida takrorlanadi va ular ustida muayyan amallarni bajaradi. Masalan, massivdagi raqamlarning kvadratlarini hisoblash uchun siz quyidagi koddan foydalanishingiz mumkin:

Var raqamlari = [1, 2, 3, 4, 5, 6]; for(var i = 0; i "); }

Ammo forEach() usulidan foydalanib, ushbu qurilishni soddalashtirishingiz mumkin:

Var raqamlari = [1, 2, 3, 4, 5, 6]; funktsiya kvadrat(qiymat, indeks, massiv) ( var natija = qiymat * qiymat; document.write("Raqam kvadrati " + qiymat + " " + natija + "
"); ); raqamlar.Har bir(kvadrat);

ForEach() usuli parametr sifatida bir xil funktsiyani oladi, unga elementlarni takrorlashda takrorlanayotgan joriy element uzatiladi va unda amallar bajariladi.

map() usuli forEach usuliga o'xshaydi; u parametr sifatida massiv elementlari ustida amallarni bajaradigan funksiyani ham oladi, lekin map() usuli massiv elementlari ustidagi amallar natijalari bilan yangi massivni qaytaradi.

Masalan, massivdagi raqamlar kvadratlarini hisoblash uchun xarita usulidan foydalanamiz:

Var raqamlari = [1, 2, 3, 4, 5, 6]; funktsiya kvadrati(qiymat, indeks, massiv) ( qaytariladigan natija = qiymat * qiymat; ); var squareArray = numbers.map(kvadrat); document.write(squareArray);

map() usuliga uzatiladigan funksiya takrorlanayotgan joriy elementni oladi, u ustida amallarni bajaradi va qandaydir qiymat qaytaradi. Keyin bu qiymat olingan kvadratArrayga kiradi

Ushbu maqolada biz raqamli indeksli standart JavaScript massivlarini ko'rib chiqamiz. Massivlar kvadrat qavslar yordamida e'lon qilinadi:

var fruits = ["Olma", "Apelsin", "Eshak"]

Elementni ajratib olish uchun uning indeksini kvadrat qavs ichiga joylashtiring. Birinchi indeks 0:

var fruits = ["Olma", "Apelsin", "Eshak"] ogohlantirish(mevalar) ogohlantirish(mevalar) ogohlantirish(mevalar)

JavaScript massivining uzunligini ham olishimiz mumkin:

var fruits = ["Olma", "Apelsin", "Eshak"] alert(fruits.length)

Voy! Biz ikkita meva va eshak bilan massiv yaratdik. Endi eshakni olib tashlashimiz kerak.

pop va push usullari

JavaScript-dagi pop usuli elementni massivdan olib tashlaydi va uni qaytaradi.

Quyidagi misolda “Eshak” massivdan qanday olinishi ko‘rsatilgan:

var fruits = ["Olma", "Apelsin", "Eshak"] alert("Men "+fruits.pop() o'chiryapman) // Endi bizda faqat ["Olma","Orange"] alert("Endi" bor. massivning o'lchami : "+fruits.length) // eshak olib tashlandi

E'tibor bering, pop massivning o'zini o'zgartiradi.

Popning hamkasbi massivga element qo'shadigan push usulidir. Misol uchun, biz shaftoli qo'shishni unutib qo'ydik:

var fruits = ["Olma", "Apelsin"] fruits.push("Shaftoli"); // endi bizda ["Olma", "Apelsin", "Shaftoli"] alert("Oxirgi element:"+mevalar)

1. Elementlar bilan uslublar qatorini yarating” Jazz”, “Ko'k ranglar”;
2. Qiymat qo'shing " Rok-n-Roll«;
3. Ikkinchi qiymatni oxiridan "qiymati bilan almashtiring" Klassik". Siz massiv bilan yakunlashingiz kerak: " Jazz”, ”Klassik”, ”Rok-n-Roll" Kod har qanday massiv uzunligi uchun ishlashi kerak;
4. Massivdan oxirgi qiymatni oling va uni ogohlantirish orqali ko'rsating.

Yechim

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // yoki: styles = "Rock"n"Roll" // 3 ta uslub = "Klassik " // 4 ta ogohlantirish(styles.pop())

Shift/o'chirish usullari

Shift/o'chirish usullari massiv oxirida ishlaydi, lekin siz elementlarni yuqoriga siljitish uchun shiftdan ham foydalanishingiz mumkin ( massivning birinchi qiymati elementlarni siljitish orqali o'chiriladi). Unshift usuli JavaScript-ga oxiridan boshlab massivga element qo'shish imkonini beradi:

var fruits = ["Olma", "Orange"] var olma = fruits.shift() // endi bizda faqat ["Apelsin"] fruits.unshift("Limon") // endi bizda ["Limon", " Apelsin"] ogohlantirish (mevalar. uzunlik) // 2

Shift va almashtirish bir vaqtning o'zida bir nechta elementlarda ishlashi mumkin:

var fruits = ["Olma"] fruits.push("Apelsin", "Shaftoli") fruits.unshift("Ananas", "Limon") // endi massiv quyidagicha ko'rinadi: ["Ananas", "Limon", "Olma" ", "Apelsin", "Shaftoli"]

O'z-o'zini boshqarish vazifasi

Ogohlantirish orqali arr massividan tasodifiy qiymatni ko'rsatish uchun kodni yozing:

var arr = ["O'rik", "Apelsin", "Eshak", "Sabzi", "JavaScript"]

Eslatma: Tasodifiy raqamni minimaldan maksimal qiymatgacha (shu jumladan) olish uchun kod quyidagicha:

var rand = min + Math.floor(Math.random()*(maks+1-min))

Yechim

Biz 0 dan arr.length-1 (shu jumladan) gacha bo'lgan tasodifiy sonni olishimiz kerak:

var arr = ["O'rik","Apelsin","Eshak","Sabzi","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Massiv ustida takrorlash

JavaScript-da massivni takrorlash for tsikli yordamida amalga oshiriladi:

var fruits = ["Ananas", "Limon", "Olma", "Apelsin", "Shaftoli"] for(var i=0; i

O'z-o'zini boshqarish vazifasi

Berilgan massivda qiymat topadigan va uning indeksini yoki qiymat topilmasa -1 ni qaytaruvchi find(arr,value) funksiyasini yarating.

Masalan:

arr = [ "test", 2, 1.5, false ] find(arr, "test") // 0 find(arr, 2) // 1 find(arr, 1.5) // 2 find(arr, 0) // -1

Yechim

Mumkin bo'lgan yechim quyidagicha ko'rinishi mumkin:

find(massiv, qiymat) funksiyasi (for(var i=0; i

Lekin bu noto'g'ri, chunki == 0 va false o'rtasidagi farqni aniqlamaydi.

JavaScript-da massivlar bilan ishlashda === dan foydalanish to'g'riroq. Bundan tashqari, so'nggi ES5 standarti Array#indexOf funksiyasini o'z ichiga oladi. Uning yordamida biz quyidagi kabi funktsiyani belgilashimiz mumkin:

find(massiv, qiymat) funksiyasi (if (array.indexOf) array.indexOf(qiymat) for(var i=0; i) qaytariladi

indexOf usuli mavjudligini tekshirish sharti bilan findni aniqlash yanada oqilona bo'ladi.

O'z-o'zini boshqarish vazifasi

Massivni oladigan va arr dan faqat raqamli qiymatlarni o'z ichiga olgan yangi massivni qaytaruvchi filterNumeric(arr) funksiyasini yarating.

Bu qanday ishlashi kerakligiga misol:

arr = ["a", 1, "b", 2]; arr = filterNumeric(arr); // endi arr =

Yechim

Yechim massivni takrorlash va agar ular raqamli bo'lsa, qiymatlarni yangi massivga qo'shishdir.

qo'shilish va ajratish

Ba'zan sizga JavaScript massivini satrga aylantirishning tezkor usuli kerak bo'ladi. Qo'shilish usuli bu uchun.

U berilgan ajratuvchi yordamida massivni satrga birlashtiradi:

var fruits = ["Limon", "Olma", "Apelsin", "Shaftoli"]; var str = fruits.join(", "); alert(str);

Teskari konvertatsiya ajratish usuli yordamida osongina amalga oshiriladi:

var fruits = "Olma, apelsin, shaftoli"; var arr = fruits.split(","); // arr endi ["Olma", "Orange", "Peach"] alert(arr) o'z ichiga oladi;

O'z-o'zini boshqarish vazifasi

Ob'ekt bo'shliqlar bilan ajratilgan sinf nomlarini o'z ichiga olgan className xususiyatini o'z ichiga oladi:

cls sinfini qo'shadigan addClass(obj, cls) funksiyasini yozing, lekin u mavjud bo'lmasa:

ddClass(obj, "yangi") // obj.className="menyuni yangi" addClass(obj, "ochiq") // hech qanday o'zgarishlar yo'q (sinf allaqachon mavjud) addClass(obj, "men") // obj.className= "Ochiq menyu yangi meni" ogohlantirish (obj.className) //

Yechim

ClassName va tsiklni qismlarga bo'lishingiz kerak. Agar sinf topilmasa, u qo'shiladi.

Ishlashni oshirish uchun pastadir biroz optimallashtirilgan:

funktsiya addClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) return ) elem.className += " "+cls ) var obj = ( className: "menyuni ochish" ) addClass(obj, "yangi") addClass(obj, "open") alert(obj.className) // menyuni ochish yangi

Yuqoridagi misolda c o'zgaruvchisi sikl boshida aniqlanadi va uning oxirgi indeksi i ga o'rnatiladi.

Loopning o'zi i>=0 sharti bilan tugaydigan qarama-qarshi yo'nalishda qayta ishlanadi. Chunki i>=0 ni tekshirish i ga qaraganda tezroq. JavaScript-dagi narsa massivda qidirishni tezlashtiradi.

Massivni kesish uchun uzunlikdan foydalanish

Uzunlik xususiyatidan foydalanib, quyidagi kabi massivni kesishingiz mumkin:

Siz uzunlikni belgilaysiz va brauzer massivni qisqartiradi.

Massiv ob'ekt, shuning uchun bu nimani anglatadi?

Aslida, JavaScript-da Massiv - bu ob'ekt bo'lib, avtomatik uzunlik sozlamalari va maxsus usullar bilan to'la.

Bu boshqa tillardagi kontseptsiyadan farq qiladi, bu erda massivlar xotiraning qo'shni segmentini ifodalaydi. Bu, shuningdek, bog'langan ro'yxatlarga asoslangan navbat yoki stekdan farq qiladi.

Raqamli bo'lmagan massiv kalitlari

Kalitlar raqamlardir, lekin ular har qanday nomga ega bo'lishi mumkin:

arr = arr = 5 arr.prop = 10 // buni qilmang

JavaScript-da massivlar xesh-jadvallar bo'lib, ular ishlash afzalliklari bilan bir qatorda ma'lum kamchiliklarga ham ega.

Masalan, push/pop faqat massivning eng tashqi elementlarida ishlaydi, shuning uchun ular nihoyatda tezdir.

push faqat oxiri bilan ishlaydi:

var arr = ["Mening", "massiv"] arr.push("bir narsa") alert(arr) // "massiv" qatori

O'zgartirish/o'chirish usullari sekin, chunki ular butun massivni qayta raqamlashlari kerak. Bog'lanish usuli raqamlashning o'zgarishiga ham olib kelishi mumkin:

Shunday qilib, shift/unshift push/pop ga qaraganda sekinroq. Massiv qanchalik katta bo'lsa, massivni saralash uchun JavaScript shunchalik ko'p vaqt talab etadi.

O'z-o'zini boshqarish vazifasi

Natija qanday bo'ladi? Nega?

arr = ["a", "b"] arr.push(function() ( alert(bu) )) arr() // ?

Yechim

Massivlar ob'ektlar bo'lganligi sababli, arr .. aslida obj kabi ob'ektdagi usul chaqiruvidir usuli:

arr() // arr() bilan bir xil // sintaktik jihatdan noto‘g‘ri, lekin kontseptual jihatdan bir xil: arr.2() // obj.method() bilan bir xil uslubda qayta yozilgan this = arr bu holda funksiyaga uzatiladi, shuning uchun arr ning mazmuni chop etiladi. arr = ["a", "b"] arr.push(function() ( alert(bu) )) arr() // "a","b",funksiya

Siyrak massivlar, uzunlik tavsifi

Uzunlik xususiyati JavaScript-da massiv hajmini emas, balki oxirgi indeks + 1 ni olish imkonini beradi. Bu indekslarda "bo'shliqlar" bo'lgan siyrak massivlar haqida gapirganda muhimdir.

Quyidagi misolda biz bo'sh mevalarga ikkita element qo'shamiz, lekin uzunlik qiymati 100 bo'lib qoladi:

var fruits = // empty array fruits = "shaftoli" mevalari = "Olma" alert(fruits.length) // 100 (lekin massivda faqat 2 ta element mavjud)

Agar siz siyrak massivni chiqarishga harakat qilsangiz, brauzer etishmayotgan indeks qiymatlarini bo'sh elementlar sifatida qaytaradi:

var fruits = // empty array fruits = "Shaftoli" mevalari = "Olma" ogohlantirishi(mevalar) // ,Shaftoli,Olma (yoki shunga o'xshash narsa)

Ammo massiv ikkita kalitli ob'ektdir. Yo'qotilgan qiymatlar joy egallamaydi.

Massiv usullari qo'llanilganda siyrak massivlar g'alati ishlaydi. Ular indekslar etishmayotganligini bilishmaydi:

var fruits = fruits = "shaftoli" mevalari = "Apple" alert(fruits.pop()) // pop "Apple" (indeks 9) alert(fruits.pop()) // noma'lum elementni oching (indeks 8 uchun). )

Noyob massivlardan qochishga harakat qiling. Har holda, ularning usullari normal ishlamaydi. Buning o'rniga Ob'ektdan foydalaning.

Massivdan olib tashlash

Ma'lumki, massivlar ob'ektlardir, shuning uchun biz qiymatni o'chirish uchun delete dan foydalanishimiz mumkin:

var arr = ["O'tish", "to", "uy"] o'chirish arr // endi arr = ["O'tish", aniqlanmagan, "uy"] alert(arr) // aniqlanmagan

Siz qiymat o'chirilganligini ko'rishingiz mumkin, lekin biz xohlagan tarzda emas, chunki massivda aniqlanmagan element mavjud.

O'chirish operatori kalit-qiymat juftligini olib tashlaydi va tamom. Tabiiyki, massiv faqat xesh bo'lganligi sababli, olib tashlangan elementning pozitsiyasi aniqlanmagan bo'ladi.

Ko'pincha biz indekslar orasida "teshiklar" qoldirmasdan elementni olib tashlashimiz kerak. Bunda bizga yordam beradigan yana bir usul bor.

ulash usuli

Splice usuli elementlarni olib tashlashi va ularni JavaScript ko'p o'lchovli massivlarida almashtirishi mumkin. Uning sintaksisi:

arr.splice(indeks, deleteCount[, elem1, ..., elemN])

Indeksdan boshlab deleteCount elementini olib tashlaydi va uning o'rniga elem1, ..., elemN ni kiritadi.

Keling, bir nechta misollarni ko'rib chiqaylik:

var arr = ["O'tish", "to", "uy"] arr.splice(1, 1) // 1 indeksdan boshlanadigan 1 elementni o'chirish alert(arr.join(",")) // ["O'tish " , "uy"] (1 ta element olib tashlandi)

Shunday qilib, massivdan bitta elementni olib tashlash uchun splice dan foydalanishingiz mumkin. Massiv elementlari raqamlari bo'sh joyni to'ldirish uchun o'zgartiriladi:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // 0 indeksdan boshlab 1 ta elementni olib tashlang alert(arr) // "to" birinchi elementga aylandi

Quyidagi misol elementlarni qanday almashtirishni ko'rsatadi:

Splice usuli olib tashlangan elementlar qatorini qaytaradi:

var arr = ["Borish", "ga", "uy", "hozir"]; // birinchi 2 elementni olib tashlang var o'chirildi = arr.splice(0, 2) alert(o'chirildi) // "O'tish", "to"<-- массив удаленных элементов splice может вставлять элементы, задайте 0 для deleteCount. var arr = ["Go", "to", "home"]; // со второй позиции // удаляем 0 // и вставляем "my", "sweet" arr.splice(2, 0, "my", "sweet") alert(arr) // "Go", "to", "my", "sweet", "home"

Ushbu usul massiv oxiridan boshlab hisoblangan salbiy indeksdan ham foydalanishi mumkin:

var arr = // element uchun -1 (oxirgidan oldingi) // 0 elementni olib tashlang, // va 3 va 4 arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

O'z-o'zini boshqarish vazifasi

Ob'ektda bo'shliqlar bilan ajratilgan sinf nomlarini o'z ichiga olgan className xususiyati mavjud:

var obj = (sinf nomi: "menyuni ochish")

Agar berilgan bo'lsa, cls sinfini olib tashlaydigan removeClass(obj, cls) funksiyasini yozing:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // hech qanday o'zgarishlar yo'q (o'chirish uchun sinf yo'q)

Yechim

Siz className ni qismlarga bo'lishingiz va bu qismlarni aylanib o'tishingiz kerak. Agar moslik topilsa, u JavaScript ob'ektlar qatoridan o'chiriladi va keyin yana oxiriga qo'shiladi.

Keling, buni biroz optimallashtiramiz:

function removeClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( className: "open menu" ) removeClass(obj, "open") removeClass(obj, "blabla") alert (obj.className) // menyu

Yuqoridagi misolda c o'zgaruvchisi sikl boshida, i esa uning oxirgi indeksiga o'rnatiladi.

Halqaning o'zi i>=0 sharti bilan tugaydigan qarama-qarshi yo'nalishda ishlaydi. Bu amalga oshiriladi, chunki i>=0 i dan tezroq tekshiriladi. Qaysi c ichida xususiyatlarni qidirishni tezlashtiradi.

kesish usuli

Siz massivning bir qismini slice(begin[, end]) usuli yordamida ajratib olishingiz mumkin: var arr = ["Nega", "o'rganish", "JavaScript"]; var arr2 = arr.slice(0,2) // 0 dan boshlab 2 ta elementni oladi alert(arr2.join(", ")) // "Nega, o'rganing"

Shuni esda tutingki, bu usul JavaScript-da massivdagi elementlar sonini o'zgartirmaydi, balki uning bir qismini nusxalaydi.

Muayyan indeksdan boshlangan barcha elementlarni olish uchun ikkinchi argumentni o'tkazib yuborishingiz mumkin:

var arr = ["Nima uchun", "o'rganish", "JavaScript"]; var arr2 = arr.slice(1) // 1 alert(arr2.join(", ")) dan boshlab barcha elementlarni oladi // "o'rganing, JavaScript"

Usul xuddi String#slice kabi salbiy indekslarni qo'llab-quvvatlaydi.

teskari usul

Yana bir foydali usul teskari. Aytaylik, men domenning oxirgi qismini olmoqchiman " com"dan" my.site.com" Buni qanday qilish kerak:

var domain = "my.site.com" var last = domain.split(".").reverse() alert(oxirgi)

E'tibor bering, JavaScript massivlari usulni chaqirish va natijada olingan massivdan elementni olish uchun murakkab sintaksisni (teskari ()) qo'llab-quvvatlaydi.

Reverse() kabi uzoqroq qoʻngʻiroqlarni yaratishingiz mumkin. 0] arr.sort() alert(arr) // 1, 15, 2

Yuqoridagi kodni ishga tushiring. Siz 1, 15, 2 buyurtmalarini olasiz. Buning sababi shundaki, usul hamma narsani satrga aylantiradi va sukut bo'yicha leksikografik tartibdan foydalanadi.