Massiv usullari

Massivlar juda kop usullarni taqdim etadi. Ishlarni engillashtirish uchun ushbu bobda ular guruhlarga bolingan.

Elementlarni qoshish/olib tashlash

Biz allaqachon elementlarni boshidan yoki oxiridan qoshib olib tashlaydigan usullarni bilamiz:

• arr.push(...items) oxiriga narsalarni qoshadi,
• arr.pop() oxiridan elementni ajratib oladi,
• arr.shift() boshidan elementni ajratib oladi,
• arr.unshift(...items) elementlarni boshiga qoshadi.

Mana boshqalar.

splice

Massivdan elementni qanday ochirish mumkin?

Massivlar obyektlardir, shuning uchun biz delete dan foydalanishga urinib korishimiz mumkin:

let arr = ["I", "go", "home"];

delete arr[1]; // "go" olib tashlash

alert(arr[1]); // undefined

// hozir arr = ["I",  , "home"];
alert(arr.length); // 3

Element ochirildi, ammo massivda hali ham 3 ta element mavjud, biz buni korishimiz mumkin arr.length == 3.

Bu tabiiy, chunki obj.key ni ochirish key yordamida qiymatni olib tashlaydi. Hammasi shu. Obyektlar uchun yaxshi. Ammo massivlar uchun biz odatda qolgan elementlarning siljishini va bosh joyni egallashini istaymiz. Biz hozirda qisqaroq massivga ega bolishni kutmoqdamiz.

Shunday qilib, maxsus usullardan foydalanish kerak.

arr.splice(str) usuli bu massivlar uchun Shveytsariya armiyasining pichogi. U hamma narsani qilishi mumkin: elementlarni qoshish, olib tashlash va kiritish.

Sintaksis:

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

U indeks pozitsiyasidan boshlanadi: deleteCount elementlarini olib tashlaydi va keyin ularning orniga elem1, ..., elemN qoshadi. Ochirilgan elementlar masssivini qaytaradi.

Ushbu usulni misollar yordamida tushunish oson.

Ochirish bilan boshlaymiz:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // 1-indeksdan 1 ta elementni olib tashlang

alert( arr ); // ["I", "JavaScript"]

Oson, togrimi? 1 indeksidan boshlab, u 1 elementni olib tashladi.

Keyingi misolda biz uchta elementni olib tashlaymiz va ularni qolgan ikkitasi bilan almashtiramiz:

let arr = ["I", "study", "JavaScript", "right", "now"];

// birinchi uchta elementni olib tashlang va ularni boshqasiga almashtiring
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // hozir ["Let's", "dance", "right", "now"]

Bu erda splice ochirilgan elementlar massivini qaytarishini korishimiz mumkin:

let arr = ["I", "study", "JavaScript", "right", "now"];

// birinchi ikkita elementni olib tashlang
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- o'chirilgan elementlarning massivi

splice usuli elementlarni hech qanday olib tashlamasdan kiritishga qodir. Buning uchun biz deleteCount ni 0 ga ornatishimiz kerak:

let arr = ["I", "study", "JavaScript"];

// indeks 2 dan
// o'chirish 0
// keyin "complex" va "language" ni kiriting
arr.splice(2, 0, "complex", "language");

alert(arr); // "I", "study", "complex", "language", "JavaScript"

let arr = [1, 2, 5];

// from index -1 (oxiridan bir qadam)
// 0 elementni o'chirish,
// keyin 3 va 4 ni kiriting
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

slice

arr.slice usuli oxshash arr.splice ga qaraganda ancha sodda.

Sintaksis:

arr.slice([start], [end]);

U "start" dan "end" gacha ("end" hisobga olinmagan) barcha elementlarni oz ichiga olgan yangi massivni qaytaradi. Har ikkala start va end ham salbiy bolishi mumkin, bu holda massiv oxiridan pozitsiya qabul qilinadi.

U str.slice kabi ishlaydi, lekin submatnlar orniga submassivlar yaratadi.

Masalan:

let arr = ["t", "e", "s", "t"];

alert(arr.slice(1, 3)); // e,s (copy from 1 to 3)

alert(arr.slice(-2)); // s,t (copy from -2 till the end)

We can also call it without arguments: arr.slice() creates a copy of arr. Thats often used to obtain a copy for further transformations that should not affect the original array.

concat

Metod arr.concat massivni boshqa massivlar va/yoki elementlar bilan birlashtiradi.

Sintaksis:

arr.concat(arg1, arg2...)

U har qanday argumentlarni qabul qiladi yoki massivlar, yoki qiymatlar.

Natijada arr, keyin arg1, arg2 va hokazolarni oz ichiga olgan yangi massiv hosil boladi.

Agar argument massiv bolsa yoki Symbol.isConcatSpreadable xususiyatiga ega bolsa, unda uning barcha elementlari kochiriladi. Aks holda, argumentning ozi kochiriladi.

Masalan:

let arr = [1, 2];

// arr ni [3,4] bilan birlashtirish
alert(arr.concat([3, 4])); // 1,2,3,4

// arr ni [3,4] va [5,6] bilan birlashtirish
alert(arr.concat([3, 4], [5, 6])); // 1,2,3,4,5,6

// arr ni [3,4] bilan birlashtirish, so'ngra 5 va 6 qiymatlarini qo'shish
alert(arr.concat([3, 4], 5, 6)); // 1,2,3,4,5,6

Odatda, u faqat elementlarni massivlardan kochiradi (ularni tarqatadi). Boshqa obyektlar, hatto ular massivga oxshash bolsa ham, umuman qoshiladi:

let arr = [1, 2];

let arrayLike = {
  0: "something",
  length: 1,
};

alert(arr.concat(arrayLike)); // 1,2,[object Object]

Agar massivga oxshash obyektda Symbol.isConcatSpreadable xususiyati bolsa, uning orniga uning elementlari qoshiladi:

let arr = [1, 2];

let arrayLike = {
  0: "something",
  1: "else",
  [Symbol.isConcatSpreadable]: true,
  length: 2
};

alert( arr.concat(arrayLike) ); // 1,2,something,else

Takrorlash: forEach

arr.forEach usuli massivning har bir elementi uchun funktsiyani bajarishga imkon beradi.

Sintaksis:

arr.forEach(function (item, index, array) {
  // ... item bilan biror narsa qilish
});

Masalan, bu massivning har bir elementini korsatadi:

// har bir element uchun ogohlantirish
["Bilbo", "Gandalf", "Nazgul"].forEach(alert);

Va ushbu kod maqsadli massivda ularning pozitsiyalari haqida batafsilroq malumot berilgan:

["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
  alert(`${item} ${array} massivida ${index} indeksida`);
});

Funktsiya natijasi (agar u biron bir narsani qaytarsa) tashlanadi va etiborga olinmaydi.

Massivda qidirish

Bu massivda biror narsani qidirish usullari.

indexOf/lastIndexOf va includes

arr.indexOf, arr.lastIndexOf va arr.includes usullari bir xil sintaksisga ega. va aslida ularning matnga oxshashadi, lekin belgilar orniga elementlarda ishlashadi:

• arr.indexOf(item, from) from indeksdan boshlab item ni qidiradi va topilgan joyning indeksini qaytaradi, aks holda -1.
• arr.lastIndexOf(item, from) xuddi shunday, lekin ongdan chapga qidiradi.
• arr.includes(item, from) from indeksdan boshlab item ni izlaydi, agar topilsa true qiymatini beradi.

Masalan:

let arr = [1, 0, false];

alert(arr.indexOf(0)); // 1
alert(arr.indexOf(false)); // 2
alert(arr.indexOf(null)); // -1

alert(arr.includes(1)); // true

Etibor bering, usullarda === taqqoslash qollaniladi. Shunday qilib, agar biz false ni qidirsak, u nolni emas, balki false ni topadi.

Agar biz inklyuziyani tekshirishni istasak va aniq indeksni bilmoqchi bolmasak, u holda arr.includes afzal.

Bundan tashqari, include ning juda oz farqi shundaki, u indexOf/lastIndexOf dan farqli olaroq, NaN da togri ishlaydi.

const arr = [NaN];
alert(arr.indexOf(NaN)); // -1 (0 bo'lishi kerak, lekin === tenglik NaN uchun ishlamaydi)
alert(arr.includes(NaN)); // true (to'g'ri)

find va findIndex

Bizda bir obyektlar massivi mavjudligini tasavvur qiling. Muayyan shartli obyektni qanday topishimiz mumkin?

Bu yerda arr.find usuli foydalidir.

Sintaksis:

let result = arr.find(function (item, index, array) {
  // agar true qaytarilsa, element qaytariladi va takrorlash to'xtatiladi
  // false senariy uchun undefined qaytariladi
});

Funktsiya massivning har bir elementi uchun takroriy ravishda chaqiriladi:

• item element hisoblanadi.
• index bu uning indeksidir.
• array massivning ozi.

Agar u true ni qaytarsa, qidiruv toxtatiladi, item qaytariladi. Hech narsa topilmasa, undefined qaytariladi.

Masalan, bizda foydalanuvchilar massivi bor, ularning har biri id va name argumentlariga ega. Keling, id == 1 bilan topamiz:

let users = [
  { id: 1, name: "John" },
  { id: 2, name: "Pete" },
  { id: 3, name: "Mary" },
];

let user = users.find((item) => item.id == 1);

alert(user.name); // John

Haqiqiy hayotda obyektlar massivi odatiy holdir, shuning uchun find usuli juda foydali.

Etibor bering, biz misolda item => item.id == 1 funktsiyasini bitta argument bilan topish ni taminlaymiz. Ushbu funktsiyaning boshqa argumentlari kamdan kam qollaniladi.

arr.findIndex usuli asosan bir xil, ammo u elementning ozi orniga element topilgan indeksni qaytaradi va hech narsa topilmaganda -1 qaytariladi.

filter

find usuli funktsiyani true qaytaradigan yagona (birinchi) elementni qidiradi.

Agar kop bolsa, biz arr.filter(fn) dan foydalanishimiz mumkin.

Sintaksis find ga oxshaydi, lekin true allaqachon qaytarilgan bolsa ham, massivning barcha elementlari uchun filtr takrorlashni davom ettiradi:

let results = arr.filter(function (item, index, array) {
  // agar true element natijalarga chiqarilsa va takrorlanish davom etsa
  // false senariy uchun bo'sh qatorni qaytaradi
});

Masalan:

let users = [
  { id: 1, name: "John" },
  { id: 2, name: "Pete" },
  { id: 3, name: "Mary" },
];

// dastlabki ikkita foydalanuvchi massivini qaytaradi
let someUsers = users.filter((item) => item.id < 3);

alert(someUsers.length); // 2

Massivni ozgartirish

Ushbu bolim massivni ozgartirish yoki qayta tartiblash usullari haqida.

map

arr.map usuli eng foydali va tez-tez ishlatiladigan usullardan biridir.

Sintaksis:

let result = arr.map(function (item, index, array) {
  // element o'rniga yangi qiymatni qaytaradi
});

U massivning har bir elementi uchun funktsiyani chaqiradi va natijalar massivini qaytaradi.

Masalan, biz har bir elementni uning uzunligiga aylantiramiz:

let lengths = ["Bilbo", "Gandalf", "Nazgul"].map((item) => item.length);
alert(lengths); // 5,7,6

sort(fn)

arr.sort usuli massivni joyida tartiblaydi.

Masalan:

let arr = [1, 2, 15];

// usul arr tarkibini qayta tartibga soladi (va uni qaytaradi)
arr.sort();

alert(arr); // 1, 15, 2

Natijada qandaydir galati narsani sezdingizmi?

Tartib 1, 15, 2 boldi. Notogri. Lekin nega?

Sukut boyicha elementlar matn sifatida tartiblangan.

Togridan-togri, barcha elementlar matnlarga aylantiriladi va keyin taqqoslanadi. Shunday qilib, leksikografik tartib qollaniladi va haqiqatan ham "2" > "15".

Ozimizning tartiblash usulimizdan foydalanish uchun biz ikkita argumentning funktsiyasini array.sort() argumenti sifatida taminlashimiz kerak.

Funktsiya shunday ishlashi kerak:

function compare(a, b) {
  if (a > b) return 1; // if the first value is greater than the second
  if (a == b) return 0; // if values are equal
  if (a < b) return -1; // if the first value is less than the second
}

Masalan:

function compareNumeric(a, b) {
  if (a > b) return 1;
  if (a == b) return 0;
  if (a < b) return -1;
}

let arr = [ 1, 2, 15 ];

arr.sort(compareNumeric);

alert(arr);  // 1, 2, 15

Endi u maqsadga muvofiq ishlaydi.

Keling, chetga chiqib, nima bolayotganini oylab koraylik. arr har qanday narsaning massivi bolishi mumkin, shunday emasmi? Unda raqamlar yoki matnlar yoki HTML elementlari yoki boshqa narsalar bolishi mumkin. Bizda bir narsa toplami mavjud. Uni saralash uchun uning elementlarini taqqoslashni biladigan tartiblash funktsiyasi kerak. Sukut boyicha matn tartibi.

arr.sort(fn) usuli tartiblash algoritmini ornatilgan dasturiga ega. Biz uning qanday ishlashiga ahamiyat berishimiz shart emas (kopincha optimallashtirilgan quicksort). U massivda yuradi, taqdim etilgan funktsiya yordamida elementlarini taqqoslaydi va ularni tartibini ozgartiradi, bizga taqqoslashni amalga oshiradigan fn kerak boladi.

Aytgancha, qaysi elementlar taqqoslanganligini bilmoqchi bolsak ularni ogohlantirishga hech narsa tosqinlik qilmaydi:

[1, -2, 15, 2, 0, 8].sort(function (a, b) {
  alert(a + " <> " + b);
  return a - b;
});

Algoritm bu jarayonda elementni bir necha marta taqqoslashi mumkin, ammo iloji boricha kamroq taqqoslashga harakat qiladi.

let arr = [ 1, 2, 15 ];

arr.sort(function(a, b) { return a - b; });

alert(arr);  // 1, 2, 15

arr.sort( (a, b) => a - b );

reverse

arr.reverse usuli arr dagi elementlarning tartibini ozgartiradi.

Masalan:

let arr = [1, 2, 3, 4, 5];
arr.reverse();

alert(arr); // 5,4,3,2,1

Bu, shuningdek, arr massivni qaytaradi.

split va join

Mana, hayotdagi holat. Biz xabar almashish dasturini yozmoqdamiz va odam qabul qiluvchilarning vergul bilan ajratilgan royxatini kiritdi: John, Pete, Mary. Ammo biz uchun ismlar massivi bitta matnga qaraganda ancha qulayroq bolar edi. Qanday qilib olish mumkin?

str.split(delim) usuli aynan shu narsani qiladi. U matnni berilgan massivga ajratadi delim.

Quyidagi misolda biz vergul bilan bosh joyni boldik:

let names = "Bilbo, Gandalf, Nazgul";

let arr = names.split(", ");

for (let name of arr) {
  alert(`A message to ${name}.`); // A message to Bilbo  (va boshqa ismlar)
}

split usuli ixtiyoriy ikkinchi raqamli argumentga ega bu massiv uzunligining chegarasi. Agar u taqdim etilsa, unda qoshimcha elementlar etiborga olinmaydi. Amalda u kamdan-kam hollarda qollaniladi:

let arr = "Bilbo, Gandalf, Nazgul, Saruman".split(", ", 2);

alert(arr); // Bilbo, Gandalf

let str = "test";

alert( str.split('') ); // t,e,s,t

arr.join(separator) chaqiruvi split ga teskari harakat qiladi. U orasida separator bilan yopishtirilgan arr matnini yaratadi.

Masalan:

let arr = ["Bilbo", "Gandalf", "Nazgul"];

let str = arr.join(";"); // glue the array into a string using ;

alert(str); // Bilbo;Gandalf;Nazgul

reduce/reduceRight

Biz massivni takrorlashimiz kerak bolganda forEach, for yoki for..of dan foydalanishimiz mumkin.

Har bir element uchun malumotlarni takrorlash va qaytarish kerak bolganda biz map dan foydalanishimiz mumkin.

arr.reduce va arr.reduceRight usullari ham ushbu zotga tegishli, ammo biroz murakkabroq. Ular massiv asosida bitta qiymatni hisoblash uchun ishlatiladi.

Sintaksis:

let value = arr.reduce(
  function (accumulator, item, index, array) {
    // ...
  },
  [initial]
);

Funktsiya elementlarga qollaniladi. Siz 2-dan boshlab tanish bolgan argumentlarni korishingiz mumkin:

• item joriy massiv elementi.
• index uning pozitsiyasi.
• array bu massiv.

Hozircha, forEach/map kabi. Ammo yana bir argument bor:

• previousValue oldingi funktsiya chaqiruvining natijasidir, birinchi chaqiruv uchun boshlang'ich.

Buni tushunishning eng oson usuli, bu misol.

Bu erda biz bitta satrda massiv yigindisini olamiz:

let arr = [1, 2, 3, 4, 5];

let result = arr.reduce((sum, current) => sum + current, 0);

alert(result); // 15

Bu erda biz faqat 2 ta argumentdan foydalanadigan reduce ning eng keng tarqalgan variantini qolladik.

Keling, nima bolayotganini batafsil korib chiqamiz.

1. Birinchi bajarilishda sum boshlangich qiymat (reduce ning songgi argumenti), 0 ga teng, va joriy qiymat bu birinchi massiv elementi, 1 ga teng. Shunday qilib natija 1 dir.
2. Ikkinchi bajarilishda sum = 1, unga ikkinchi massiv elementini (2) qoshamiz va qaytaramiz.
3. Uchinchi bajarilishda sum = 3 va unga yana bitta element qoshamiz va hokazo

Hisoblash oqimi:

[]

Yoki jadval shaklida, bu yerda har bir satr keyingi qator elementidagi funktsiya chaqiruvini ifodalaydi:

Korib turganimizdek, avvalgi qongiroq natijasi keyingisining birinchi argumentiga aylanadi.

Shuningdek, biz dastlabki qiymatni qoldirib yuborishimiz mumkin:

let arr = [1, 2, 3, 4, 5];

// reduce dan boshlang'ich qiymat o'chirildi (0 yo'q)
let result = arr.reduce((sum, current) => sum + current);

alert(result); // 15

Natija bir xil. Buning sababi shundaki, agar boshlangich bolmasa, unda reduce massivning birinchi elementini boshlangich qiymati sifatida qabul qiladi va takrorlashni 2-elementdan boshlaydi.

Hisoblash jadvali yuqoridagi kabi, birinchi qatorni olib tashlagach.

Ammo bunday foydalanish juda ehtiyotkorlik talab qiladi. Agar massiv bosh bolsa, u holda reduce chaqiruvi xatolikka olib keladi.

Mana bir misol:

let arr = [];

// Xato: boshlang'ich qiymati bo'lmagan bo'sh massivni kamaytirish
// agar boshlang'ich qiymat mavjud bo'lsa, reduce uni bo'sh arr uchun qaytaradi.
arr.reduce((sum, current) => sum + current);

Shuning uchun har doim boshlangich qiymatni korsatish tavsiya etiladi.

arr.reduceRight usuli ham xuddi shunday qiladi, lekin ongdan chapga ishlaydi.

Array.isArray

Massivlar alohida til turini hosil qilmaydi. Ular obyektlarga asoslangan.

Shunday qilib, typeof oddiy obyektni massivdan ajratishga yordam bermaydi:

alert(typeof {}); // obyekt
alert(typeof []); // bir xil

Ammo massivlar shu qadar tez-tez ishlatiladiki, buning uchun maxsus usul mavjud: Array.isArray(value). Agar value massiv bolsa, true, aks holda false ni qaytaradi.

alert(Array.isArray({})); // false

alert(Array.isArray([])); // true

Kop usullar thisArg ni qollab-quvvatlaydi

find, filter, map kabi funktsiyalarni chaqiradigan deyarli barcha massiv usullari, sort dan tashqari, thisArg qoshimcha parametrlarini qabul qiladi.

Ushbu parametr yuqoridagi bolimlarda tushuntirilmagan, chunki u kamdan kam qollaniladi. Ammo toliqlik uchun biz buni qoplashimiz kerak.

Mana ushbu usullarning toliq sintaksisi:

arr.find(func, thisArg);
arr.filter(func, thisArg);
arr.map(func, thisArg);
// ...
// thisArg ixtiyoriy oxirgi argument

thisArg parametrining qiymati func uchun this ga aylanadi.

Masalan, bu erda biz filtr sifatida obyekt usulidan foydalanamiz va thisArg foydalidir:

let army = {
  minAge: 18,
  maxAge: 27,
  canJoin(user) {
    return user.age >= this.minAge && user.age < this.maxAge;
  }
};

let users = [
  {age: 16},
  {age: 20},
  {age: 23},
  {age: 30}
];

// barcha user userdan yoshroq deb toping
let youngerUsers = users.filter(user.younger, user);

alert(soldiers.length); // 2
alert(soldiers[0].age); // 20
alert(soldiers[1].age); // 23

Yuqoridagi qongiroqda biz user.younger dan filtr sifatida foydalanamiz va buning uchun kontekst sifatida user ni taqdim etamiz. Agar biz kontekstni taqdim qilmagan bolsak, users.filter(user.younger) user.younger ni mustaqil funktsiya sifatida this = undefined bilan chaqiradi. Bu darhol xato degani.

Xulosa

Massiv usullaridan qollanma:

• Elementlarni qoshish/olib tashlash uchun:

  • push(...items) oxiriga elementlarni qoshadi,
  • pop() elementni oxiridan ajratib oladi,
  • shift() boshidan elementni ajratib oladi,
  • unshift(...items) elementlarni boshiga qoshadi.
  • splice(pos, deleteCount, ...items) pos indeksda deleteCount elementlarni ochirish va items ni qoshish.
  • slice(start, end) yangi massiv yaratadi, elementlarni start dan end gacha (shu jumladan emas) massivga kochiradi.
  • concat(...items) yangi massivni qaytaradi: mavjud bolgan barcha azolarni nusxalaydi va unga items larni qoshadi. Agar items ning birortasi massiv bolsa, unda uning elementlari olinadi.

• Elementlar orasida qidirish uchun:

  • indexOf/lastIndexOf(item, pos) pos holatidan boshlab item ni qidiradi, va indeksni qaytaradi, topilmasa -1 ni.
  • includes(value) agar massivda value bolsa true, aks holda false qaytariladi.
  • find/filter(func) funktsiya orqali elementlar filtrlaniladi, true qaytaradigan barcha qiymatlarni qaytaradi.
  • findIndex find ga oxshaydi, lekin qiymat orniga indeksni qaytaradi.

• Elementlar ustida takrorlash uchun:

  • forEach(func) har bir element uchun func ni chaqiradi, hech narsa qaytarmaydi.

• Massivni ozgartirish uchun:

  • map(func) har bir element uchun func ni chaqirish natijalaridan yangi massiv yaratadi.
  • sort(func) massivni joyida saralaydi, keyin qaytaradi.
  • reverse() massivni teskariga ozgartiradi, keyin qaytaradi.
  • split/join matnni massivga va orqaga aylantiradi.
  • reduce(func, initial) har bir element uchun func chaqirib, chaqiruvlar orasidagi oraliq natijani berib, massiv ustida bitta qiymatni hisoblaydi.

• Qoshimcha:

  • Array.isArray(arr) arr massiv ekanligini tekshiradi.

Iltimos etibor bering, sort, reverse va splice usullari massivni ozini ozgartiradi.

Ushbu usullar eng kop ishlatiladigan usullar bolib, ular 99% holatlarni qamrab oladi. Ammo boshqalar ham bor:

• arr.some(fn)/arr.every(fn) massivni tekshiradi.

  fn funktsiyasi massivning har bir elementida map ga oxshash chaqiriladi. Agar natijala/natijalar true bolsa, true, aks holda false ni qaytaradi.

• arr.fill(value, start, end) qatorni start dan end gacha takrorlanadigan value bilan toldiradi.

• arr.copyWithin(target, start, end) uning elementlarini start pozitsiyasidan end pozitsiyasiga oziga, target pozitsiyasida nusxalash (mavjudligini qayta yozish).

Toliq royxat uchun qollanma ga qarang

Birinchi qarashdan juda kop usullar borligi esga olinishi qiyin tuyulishi mumkin. Ammo aslida bu korinadiganidan ancha osonroq.

Ulardan xabardor bolish uchun qollanmani korib chiqing. Keyin ushbu bobning vazifalarini amaliy ravishda hal qiling, shunda siz massiv usullari bilan tajribangizga ega bolasiz.

Keyinchalik, qachondir siz massiv bilan biror narsa qilishingiz kerak bolsa va qanday qilishni bilmasangiz bu yerga keling, qollanmaga qarang va togri usulni toping. Uni togri yozishga misollar yordam beradi. Yaqinda siz usullarni avtomatik ravishda eslab qolasiz.