# JavaScript Set va Map

> Set va Map: takrorlanmas to'plam, istalgan turdagi kalitlar, massiv va obyektdan farqi hamda amaliy qo'llanishi. Ma'lumot saqlashning qulay usullari.

Manba: https://learncode.uz/javascript/set-map/
Sana: 2026-06-04

[Massiv](https://learncode.uz/javascript/massivlar) va [obyekt](https://learncode.uz/javascript/obyektlar) ko'p
vazifani bajaradi, lekin ikkita cheklovi bor: massivda takror qiymatlar
bo'ladi, obyektda kalit faqat matn bo'la oladi. **Set** va **Map** shu
bo'shliqni to'ldiradi.

## Set — takrorlanmas to'plam

```js
const numbers = new Set([1, 2, 2, 3, 3, 3]);

console.log(numbers);
console.log(numbers.size);
```

Takrorlar avtomatik tushib qoldi. `size` — elementlar soni (`length` emas).

> **Atama**
>
> **Set** — har bir qiymat faqat **bir marta** saqlanadigan to'plam. Tartib
> qo'shilish tartibida saqlanadi, lekin indeks bo'yicha murojaat qilinmaydi.

## Set amallari

```js
const basket = new Set();

basket.add("olma");
basket.add("banan");
basket.add("olma");

console.log(basket.size);
console.log(basket.has("olma"));
console.log(basket.has("uzum"));

basket.delete("banan");
console.log([...basket]);

basket.clear();
console.log(basket.size);
```

To'rt asosiy metod: `add`, `has`, `delete`, `clear`.

## Eng ko'p ishlatiladigan holat — takrorni olib tashlash

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

const unique = [...new Set(numbers)];
console.log(unique);

const titles = ["Aziz", "Dilnoza", "Aziz", "Bobur"];
console.log([...new Set(titles)]);
```

Massivni `Set` ga o'girib, [spread](https://learncode.uz/javascript/es6-sintaksis) bilan qaytarish
— eng qisqa usul.

## has tezligi

```js
const bigArray = [];
const bigSet = new Set();

for (let i = 0; i < 100000; i++) {
  bigArray.push(i);
  bigSet.add(i);
}

let startTime = Date.now();
for (let i = 0; i < 1000; i++) bigArray.includes(99999);
console.log("Massiv:", Date.now() - startTime, "ms");

startTime = Date.now();
for (let i = 0; i < 1000; i++) bigSet.has(99999);
console.log("Set:", Date.now() - startTime, "ms");
```

Farq katta: massiv har safar boshdan qidiradi, `Set` esa qiymatni to'g'ridan
topadi. Ko'p marta "bormi?" deb so'raladigan joyda `Set` ishlating.

## To'plam amallari

```js
const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5, 6]);

const intersection = [...a].filter((x) => b.has(x));
console.log("Kesishma:", intersection);

const union = [...new Set([...a, ...b])];
console.log("Birlashma:", union);

const difference = [...a].filter((x) => !b.has(x));
console.log("Ayirma:", difference);
```

## Map — istalgan turdagi kalit

```js
const map = new Map();

map.set("text", "matn kaliti");
map.set(42, "num kaliti");
map.set(true, "mantiqiy kalit");

const obj = { id: 1 };
map.set(obj, "obj kaliti");

console.log(map.get(42));
console.log(map.get(obj));
console.log(map.size);
```

Obyektda bu mumkin emas — u kalitni matnga aylantiradi:

```js
const plain = {};
plain[42] = "num";
plain[true] = "mantiqiy";

console.log(Object.keys(plain));
console.log(typeof Object.keys(plain)[0]);
```

Kalitlar matnga aylandi. `Map` esa turni **saqlaydi**.

## Map amallari

```js
const scores = new Map([
  ["Aziz", 85],
  ["Dilnoza", 92],
]);

scores.set("Bobur", 78);

console.log(scores.get("Aziz"));
console.log(scores.has("Bobur"));
console.log(scores.size);

scores.delete("Aziz");
console.log([...scores.keys()]);
console.log([...scores.values()]);
```

## Map bo'ylab yurish

```js
const scores = new Map([
  ["Aziz", 85],
  ["Dilnoza", 92],
  ["Bobur", 78],
]);

for (const [name, score] of scores) {
  console.log(name + ": " + score);
}

const passed = [...scores].filter(([, score]) => score >= 80);
console.log(passed);
```

`Map` to'g'ridan-to'g'ri `for...of` bilan ishlaydi va har element
`[kalit, qiymat]` juftligi bo'ladi — [destructuring](https://learncode.uz/javascript/es6-sintaksis)
bilan ajratiladi.

Obyektda esa `Object.entries` kerak bo'lardi.

## Amaliy misol — sanash

```js
const words = ["olma", "banan", "olma", "uzum", "banan", "olma"];

const account = new Map();

for (const word of words) {
  account.set(word, (account.get(word) ?? 0) + 1);
}

for (const [word, count] of account) {
  console.log(word + ": " + count);
}

const topEntry = [...account].sort((a, b) => b[1] - a[1])[0];
console.log("Eng ko'p:", topEntry[0], "—", topEntry[1], "marta");
```

`??` operatori birinchi uchrashda `0` beradi — [nullish
operatori](https://learncode.uz/javascript/es6-sintaksis) shu yerda qulay.

## Qaysi birini tanlash

| Vazifa | Tanlov |
|---|---|
| Tartiblangan ro'yxat, indeks kerak | Massiv |
| Takrorsiz qiymatlar, tez `has` | **Set** |
| Matn kalitli sozlama, JSON | Obyekt |
| Istalgan turdagi kalit, tez-tez qo'shish/o'chirish | **Map** |

> **JSON bilan ishlamaydi**
>
> `Set` va `Map` ni `JSON.stringify` saqlay olmaydi — natija bo'sh obyekt
> bo'ladi. Saqlash uchun avval massivga o'giring: `[...toplam]` yoki
> `[...xarita]`.

## Amaliy mashq

1. Takrorli massivdan `Set` bilan nusxalarni olib tashlang;
2. `add`, `has`, `delete` ni sinang;
3. ikki `Set` ning kesishmasini toping;
4. `Map` da obyektni kalit sifatida ishlating;
5. matndagi so'zlarni `Map` bilan sanang;
6. `Map` ni `JSON.stringify` qilib, nima chiqishini ko'ring.

## Qisqacha xulosa

- **Set** — takrorlanmas qiymatlar to'plami; `add`, `has`, `delete`, `size`.
- `[...new Set(arr)]` — takrorni olib tashlashning eng qisqa yo'li.
- `Set.has` massivdagi `includes` dan ancha tez.
- **Map** — istalgan turdagi kalit bilan ishlaydigan juftliklar to'plami.
- `Map` `for...of` bilan `[kalit, qiymat]` juftligini beradi.
- Ikkalasi ham JSON'ga to'g'ridan-to'g'ri sig'maydi.

Keyingi darsda [regulyar ifodalar](https://learncode.uz/javascript/regex) — matn ichidan naqsh
bo'yicha qidirish.