Massiv metodlari — find, findIndex, some, every, flat, flatMap

~20 daq · JavaScript · Ob'ektlar va Massivlar

Muammodan boshlaylik

Foydalanuvchilar ro'yxatida bitta foydalanuvchini topish kerak. ID si 42 bo'lgan.

const foydalanuvchilar = [
  { id: 1,  ism: "Ali",    faol: true  },
  { id: 42, ism: "Malika", faol: false },
  { id: 7,  ism: "Sardor", faol: true  },
];

filter ishlatsa — massiv qaytaradi, bitta element ham bo'lsa. Keyin [0] qo'shish kerak. Noqulay.

const topildi = foydalanuvchilar.filter(f => f.id === 42)[0];

find aynan shu uchun — bitta element topish.

find — bitta element topish

find — shartga mos birinchi elementni qaytaradi. Topilmasa — undefined.

const foydalanuvchilar = [
  { id: 1,  ism: "Ali"    },
  { id: 42, ism: "Malika" },
  { id: 7,  ism: "Sardor" },
];

const topildi = foydalanuvchilar.find(f => f.id === 42);

console.log(topildi); // { id: 42, ism: "Malika" }

Topilmasa:

const topildi = foydalanuvchilar.find(f => f.id === 999);
console.log(topildi); // undefined

find vs filter farqi:

findIndex — indeksini topish

findIndex — find ga o'xshash, lekin elementning o'zini emas, indeksini qaytaradi. Topilmasa — -1.

const mevalar = ["olma", "nok", "o'rik", "olcha"];

const indeks = mevalar.findIndex(m => m === "o'rik");
console.log(indeks); // 2

const yoq = mevalar.findIndex(m => m === "banan");
console.log(yoq); // -1

Indeks kerak bo'lgan holat — elementni topib, splice bilan o'chirish:

const vazifalar = ["Uyga boring", "Xat yozing", "Kitob o'qing"];

const indeks = vazifalar.findIndex(v => v === "Xat yozing");
if (indeks !== -1) {
  vazifalar.splice(indeks, 1); // ← o'chiramiz
}

console.log(vazifalar); // ["Uyga boring", "Kitob o'qing"]

some — kamida bittasi shartga mosmi?

some — massivdagi kamida bitta element shartga mos bo'lsa true, hech biri bo'lmasa false qaytaradi.

Hayotiy o'xshatma

Sinf jurnali. "Bu sinfda a'lochi o'quvchi bormi?" — bitta bo'lsa ham yetarli. Topilishi bilanoq tekshirishni to'xtatadi.

const baholar = [3, 4, 3, 5, 4];

const alochi = baholar.some(b => b === 5);
console.log(alochi); // true — kamida bitta 5 bor

const hammaBesh = baholar.some(b => b === 2);
console.log(hammaBesh); // false — 2 yo'q

Real holat — savatda sotib bo'lmaydigan mahsulot bormi?

const savat = [
  { nomi: "Noutbuk", mavjud: true  },
  { nomi: "Telefon", mavjud: false },
  { nomi: "Quloqlik", mavjud: true },
];

const muammo = savat.some(m => !m.mavjud);
console.log(muammo); // true — "Telefon" mavjud emas
if (muammo) {
  console.log("Savatda mavjud bo'lmagan mahsulot bor!");
}

every — hammasi shartga mosmi?

every — massivdagi barcha elementlar shartga mos bo'lsa true, bittasi ham mos kelmasa false.

Hayotiy o'xshatma

Samolyotga o'tirish. "Barcha yo'lovchilar o'z o'rinlarini egallashganmi?" — hammasi bo'lsa uchadi, bittasi bo'lmasa kutiladi.

const baholar = [4, 5, 5, 4, 5];

const hammayaxshi = baholar.every(b => b >= 4);
console.log(hammayaxshi); // true — hammasi 4 yoki undan yuqori

const hammaAlo = baholar.every(b => b === 5);
console.log(hammaAlo); // false — to'rttalar ham bor

Forma validatsiyasi:

const maydonlar = [
  { nom: "ism",   qiymat: "Jasur" },
  { nom: "email", qiymat: "jasur@mail.com" },
  { nom: "parol", qiymat: "" },        // ← bo'sh
];

const hammaToldirilgan = maydonlar.every(m => m.qiymat.trim() !== "");
console.log(hammaToldirilgan); // false — parol bo'sh

some va every farqi:

Bo'sh massivda every true qaytarishi g'alati ko'rinadi. Mantiqiy asos: "bo'sh ro'yxatda shartni buZUVchi element yo'q" — shuning uchun true.

flat — ichki massivlarni yozib chiqarish

flat — ichida massiv bo'lgan massivni "tekislashtiradi". Default chuqurlik — 1.

const ichki = [1, [2, 3], [4, 5]];

console.log(ichki.flat()); // [1, 2, 3, 4, 5]

Chuqurroq ichki massivlar:

const chuqur = [1, [2, [3, [4]]]];

console.log(chuqur.flat());    // [1, 2, [3, [4]]] ← bir qadam
console.log(chuqur.flat(2));   // [1, 2, 3, [4]]   ← ikki qadam
console.log(chuqur.flat(Infinity)); // [1, 2, 3, 4] ← to'liq tekislash

Amalda — kategoriyalar ichidagi mahsulotlarni bitta ro'yxatga yig'ish:

const kategoriyalar = [
  ["Noutbuk", "Planshet"],
  ["Telefon", "Smartsaat"],
  ["Quloqlik", "Kamera"],
];

const hammasi = kategoriyalar.flat();
console.log(hammasi);
// ["Noutbuk", "Planshet", "Telefon", "Smartsaat", "Quloqlik", "Kamera"]

flatMap — map + flat birga

flatMap — avval map qiladi, keyin bir daraja flat qiladi. Ko'p holda map + flat(1) dan qulayroq.

const jumlalar = ["Salom dunyo", "JavaScript zo'r"];

// Har bir jumlani so'zlarga bo'lish
const sozlar = jumlalar.flatMap(j => j.split(" "));
console.log(sozlar); // ["Salom", "dunyo", "JavaScript", "zo'r"]

map bilan taqqoslash:

const jumlalar = ["Salom dunyo", "JavaScript zo'r"];

// map — ichki massivlar qoladi
const mapNatija = jumlalar.map(j => j.split(" "));
console.log(mapNatija); // [["Salom", "dunyo"], ["JavaScript", "zo'r"]]

// flatMap — tekislangan
const flatMapNatija = jumlalar.flatMap(j => j.split(" "));
console.log(flatMapNatija); // ["Salom", "dunyo", "JavaScript", "zo'r"]

flatMap bilan ba'zi elementlarni o'tkazib yuborish:

const sonlar = [1, 2, 3, 4, 5];

// Toq sonlarni o'chirib, juftlarni ikkiga ko'paytirish
const natija = sonlar.flatMap(n => n % 2 === 0 ? [n * 2] : []);
console.log(natija); // [4, 8] ← faqat 2 va 4, ikkilangan

Bo'sh massiv qaytarish — elementi chiqarip tashlash imkonini beradi. filter + map ning qisqa yozuvi sifatida.

Tez-tez uchraydigan xatolar

find ning natijasini tekshirmaslik:

const foydalanuvchilar = [{ id: 1, ism: "Ali" }];

const topildi = foydalanuvchilar.find(f => f.id === 99);
console.log(topildi.ism); // ❌ TypeError: Cannot read properties of undefined

// ✅ Avval undefined tekshirish
if (topildi) {
  console.log(topildi.ism);
}
// yoki
console.log(topildi?.ism); // optional chaining

findIndex natijasini !== -1 bilan tekshirmaslik:

const arr = ["a", "b", "c"];
const i = arr.findIndex(el => el === "z");

// ❌ -1 ni indeks sifatida ishlatish
arr.splice(i, 1); // splice(-1, 1) — oxirgi elementni o'chiradi! Kutilmagan natija.

// ✅ Avval tekshirish
if (i !== -1) {
  arr.splice(i, 1);
}

some o'rniga find ishlatish — faqat "bormi?" uchun:

const sonlar = [1, 2, 3, 4, 5];

// ❌ Noqulay — element kerak emas, faqat bor-yo'qligini bilish kerak
const bormi = sonlar.find(n => n > 3) !== undefined;

// ✅ Aniqroq
const bormi = sonlar.some(n => n > 3);

Xulosa

Barchasi asl massivni o'zgartirmaydi.

find — bitta element. filter — bir nechta. some — bor-yo'qligini bilish. every — hammasi mosligini bilish.

Keyingi dars

25-dars: Optional Chaining va Nullish Coalescing