# JavaScript massiv metodlari (map, filter, reduce)

> JavaScript'da massivni qayta ishlash: map bilan o'zgartirish, filter bilan tanlash, reduce bilan yig'ish hamda find va sort metodlari. Misollar bilan.

Manba: https://learncode.uz/javascript/massiv-metodlari/
Sana: 2026-05-27

Massiv ustidan `for` bilan yurish mumkin, lekin JavaScript'da bu ishlar uchun
tayyor metodlar bor. Ular kodni qisqa va maqsadi ko'rinib turadigan qiladi.

## map — har elementni o'zgartirish

```js
const prices = [8000, 12000, 15000];

const discounted = prices.map(price => price * 0.9);

console.log(prices);
console.log(discounted);
```

`map` har element ustida funksiyani bajaradi va natijalardan **yangi massiv**
yasaydi. Asl massiv o'zgarmaydi.

Xuddi shuni `for` bilan yozsak uzunroq bo'lardi:

```js
const discounted = [];
for (const price of prices) {
  discounted.push(price * 0.9);
}
```

`map` bir qatorda va nomi maqsadni aytib turibdi.

## filter — shartga mos elementlarni ajratish

```js
const numbers = [1, 2, 3, 4, 5, 6];

const evens = numbers.filter(num => num % 2 === 0);
const bigOnes = numbers.filter(num => num > 3);

console.log(evens);
console.log(bigOnes);
```

Funksiya `true` qaytargan elementlar yangi massivga tushadi.

> **Atama**
>
> **Callback** — boshqa funksiyaga argument sifatida uzatiladigan funksiya.
> `map(price => price * 0.9)` da arrow funksiya callback bo'lib xizmat qiladi:
> massiv metodi uni har element uchun chaqiradi.

## reduce — bitta qiymatga yig'ish

```js
const prices = [8000, 12000, 15000];

const total = prices.reduce((sum, price) => sum + price, 0);

console.log(total);
```

`reduce` ikki narsa oladi: callback va **boshlang'ich qiymat** (bu yerda `0`).
Callback har qadamda ikki argument oladi:

- `yigindi` — hozirgacha to'plangan natija;
- `price` — navbatdagi element.

Qadamma-qadam: `0+8000 = 8000` → `8000+12000 = 20000` → `20000+15000 = 35000`.

## find — birinchi mosini topish

```js
const students = [
  { name: "Aziz", score: 85 },
  { name: "Dilnoza", score: 92 },
  { name: "Bobur", score: 78 },
];

const topStudent = students.find(s => s.score > 90);
console.log(topStudent);

const missing = students.find(s => s.score > 99);
console.log(missing);
```

`find` **bitta** element qaytaradi (`filter` — massiv). Topilmasa `undefined`.

## some va every

```js
const scores = [85, 92, 78];

console.log(scores.some(b => b > 90));
console.log(scores.every(b => b > 90));
console.log(scores.every(b => b > 50));
```

- `some` — **kamida bittasi** shartga mos kelsa `true`;
- `every` — **hammasi** mos kelsa `true`.

## sort — tartiblash

```js
const numbers = [10, 5, 100, 1];

console.log([...numbers].sort());
console.log([...numbers].sort((a, b) => a - b));
console.log([...numbers].sort((a, b) => b - a));
```

> **sort sonlarni matn kabi tartiblaydi**
>
> Argumentsiz `sort()` elementlarni **matn** deb hisoblaydi: shuning uchun
> `100` `5` dan oldin keladi ("1" < "5"). Sonlar uchun doim taqqoslash
> funksiyasini bering: `(a, b) => a - b`.
>
> Yana bir nozik nuqta: `sort` asl massivni **o'zgartiradi**. Yuqorida
> `[...sonlar]` bilan nusxa olindi — shuning uchun asl massiv saqlanib qoldi.

## Metodlarni zanjirlash

Metodlar massiv qaytargani uchun ketma-ket ulanadi. Har bir bosqichda
[arrow funksiya](https://learncode.uz/javascript/arrow-funksiyalar) yoziladi — shakli qisqa
bo'lgani uchun zanjir o'qilishi oson qoladi:

```js
const products = [
  { title: "Olma", price: 8000 },
  { title: "Sut", price: 12000 },
  { title: "Guruch", price: 18000 },
];

const total = products
  .filter(p => p.price > 10000)
  .map(p => p.price)
  .reduce((a, b) => a + b, 0);

console.log(total);
```

O'qilishi: qimmatlarini ajrat → narxlarini ol → yig'.

## Amaliy mashq

Ma'lumotni qayta ishlang:

1. Sonlar massivini yarating va `map` bilan har birini kvadratga ko'taring;
2. `filter` bilan faqat juftlarini ajrating;
3. `reduce` bilan yig'indisini toping;
4. uchalasini bitta zanjirda birlashtiring;
5. `sort` bilan kamayish tartibida tartiblang.

4-qadamdan keyin natijani `for` sikli bilan qayta yozing — qaysi biri
o'qishga qulay?

## Qisqacha xulosa

- `map` — har elementni o'zgartirib **yangi massiv** yasaydi.
- `filter` — shartga mos elementlarni ajratadi.
- `reduce` — massivni **bitta qiymatga** yig'adi.
- `find` bitta element, `some`/`every` mantiqiy qiymat qaytaradi.
- `sort` asl massivni o'zgartiradi va sonlar uchun `(a, b) => a - b` talab qiladi.

Keyingi darsda [obyektlar](https://learncode.uz/javascript/obyektlar) — bog'liq ma'lumotni bir
joyda saqlashni ko'ramiz.