Map və Set

Açarı istənilən tipdə olan lüğət Map, unikal qiymətlər çoxluğu Set, onların çevirmələri və əməliyyatları, WeakMap və WeakSet; saymaq, təkrarları silmək və qruplaşdırmaq.

  • Orta
  • 22 dəq
  • 12 sual
  • 39 dərsdən 11-cisi

Bu dərsdə öyrənəcəksən

  • Map ilə obyekt, Set ilə massiv arasında seçim etmək və səbəbini izah etmək
  • Map və Set üzərindən keçmək, onları massivə, obyektə və JSON-a çevirmək
  • Çoxluq əməliyyatlarını, saymaq, təkrarları silmək və qruplaşdırmaq üsullarını tətbiq etmək
  • WeakMap və WeakSet-in nəyə lazım olduğunu və niyə size-ının olmadığını izah etmək

Məktəb olimpiadasına 500 qeydiyyat gəlib. Bəzi şagirdlər «Göndər» düyməsini iki dəfə basıb, sən isə bilməlisən: hər şəhərdən neçə nəfər var və kimlər həm riyaziyyata, həm də informatikaya yazılıb. Adi obyektlər və massivlərlə bunu etmək olar, amma əziyyətlidir: massivdə axtarış yavaşdır, obyekt isə hər açarı sətrə çevirir. JavaScript-də məhz bu işlər üçün iki kolleksiya var: Map (açar → qiymət) və Set (unikal qiymətlər). Bu dərsdə onları nə vaxt obyekt və massivin yerinə işlətməyi, onların üzərindən keçməyi və çevirməyi, həmçinin WeakMap və WeakSet-in nəyə lazım olduğunu öyrənəcəksən.

Map: istənilən tipdə açarı olan lüğət

MapTərif

«Açar – qiymət» cütlərinin kolleksiyası; açar istənilən qiymət ola bilər: sətir, ədəd, obyekt, hətta funksiya. Elementlər əlavə olunma ardıcıllığı ilə saxlanır.

Boş Map new Map() ilə yaradılır, ya da konstruktora [açar, qiymət] cütlərindən ibarət massiv verilir. Demək olar ki, hər iş beş metodla görülür: set(key, value) əlavə edir və ya əvəz edir, get(key) oxuyur (açar yoxdursa, undefined qaytarır), has(key) yoxlayır, delete(key) silir, clear() hamısını təmizləyir. size xassəsi elementlərin sayıdır. set Map-in özünü qaytardığı üçün çağırışları zəncir kimi yazmaq olar.

JavaScript
const capitals = new Map();
capitals.set('Azerbaijan', 'Baku');
capitals.set('Georgia', 'Tbilisi').set('Türkiye', 'Ankara');

console.log(capitals.get('Georgia'));
console.log(capitals.get('France'));
console.log(capitals.has('Azerbaijan'));
console.log(capitals.size);

capitals.delete('Türkiye');
console.log(capitals);
Gözlənilən nəticə
Tbilisi
undefined
true
3
Map(2) { 'Azerbaijan' => 'Baku', 'Georgia' => 'Tbilisi' }

Bəs niyə adi obyekt kifayət etmir? Obyektin açarları həmişə sətirdir (və ya simvol): 1 ədədi səssizcə '1' sətrinə çevrilir, açar kimi götürülən obyekt isə '[object Object]' sətrinə — yəni bütün obyektlər eyni açarda toqquşur. Map açarları heç bir çevirmə etmədən müqayisə edir.

JavaScript
const obj = {};
obj[1] = 'number one';
obj['1'] = 'string one';
console.log(Object.keys(obj));

const map = new Map();
map.set(1, 'number one');
map.set('1', 'string one');
console.log(map.size, map.get(1), map.get('1'));

const leyla = { name: 'Leyla' };
const elvin = { name: 'Elvin' };
const scores = {};
scores[leyla] = 95;
scores[elvin] = 80;
console.log(scores);

const scoreMap = new Map([[leyla, 95], [elvin, 80]]);
console.log(scoreMap.get(leyla), scoreMap.get(elvin));
Gözlənilən nəticə
[ '1' ]
2 number one string one
{ '[object Object]': 80 }
95 80

Obyektdə ikinci mənimsətmə birincinin üstündən yazdı, Elvinin balı isə Leylanınkını əvəz etdi, çünki hər iki obyekt eyni sətrə çevrildi. Map dörd elementin hamısını ayrı saxladı. Daha bir tələ: adi obyekt Object.prototype-dan xassələr miras alır. Açarlar istifadəçidən gələndə (mətndəki sözlər, istifadəçi adları) toString və ya constructor kimi söz sən əlavə etməmişdən əvvəl də obyektdə «var»:

JavaScript
const words = ['map', 'toString', 'map'];

const counts = {};
for (const w of words) counts[w] = (counts[w] || 0) + 1;
console.log(counts.map, typeof counts.toString);

const safe = new Map();
for (const w of words) safe.set(w, (safe.get(w) ?? 0) + 1);
console.log(safe.get('map'), safe.get('toString'));
Gözlənilən nəticə
2 string
2 1

counts.toString əvvəlcədən funksiya idi, «funksiya + 1» isə sətir verdi — say pozuldu. Map-də miras alınmış açar yoxdur, ona görə nəticə düzgündür. Aşağıdakı cədvəl iki aləti müqayisə edir.

XüsusiyyətObject {}Map
Açarın tipisətir və simvolistənilən qiymət
Açarların sırasıəvvəl tam ədədə bənzər açarlar artan sıra ilə, sonra qalanları əlavə olunma sırası iləhəmişə əlavə olunma sırası
Elementlərin sayıObject.keys(obj).lengthmap.size
Üzərindən keçməkObject.keys/values/entries vasitəsiləbirbaşa for...of ilə
Miras alınmış açarlarvar (toString, constructor)yoxdur
JSONJSON.stringify işləyir{} verir — əvvəlcə çevirmək lazımdır
Nə üçün yaxşıdırsahələri məlum olan bir qeyd (istifadəçi, parametrlər)böyüyüb-kiçilən, açarları verilənlərdən gələn lüğət

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

Set: yalnız unikal qiymətlər

SetTərif

Hər qiymətin ən çoxu bir dəfə olduğu kolleksiya (riyaziyyatdakı çoxluq kimi). Artıq olan qiyməti yenidən əlavə etmək heç nəyi dəyişmir.

Metodları: add(value), has(value), delete(value), clear() və size xassəsi. new Set(iterable) çoxluğu massivdən, sətirdən və ya başqa Set-dən doldurur. JavaScript-də təkrarları silməyin ən qısa yolu da buradan gəlir: [...new Set(array)].

JavaScript
const visited = new Set();
visited.add('Baku');
visited.add('Ganja');
visited.add('Baku');
console.log(visited.size);
console.log(visited.has('Ganja'), visited.has('Shaki'));
visited.delete('Ganja');
console.log(visited);

const marks = [5, 4, 5, 3, 4, 5];
const unique = [...new Set(marks)];
console.log(unique);
console.log(new Set([1, '1', NaN, NaN, 0, -0]));
Gözlənilən nəticə
2
true false
Set(1) { 'Baku' }
[ 5, 4, 3 ]
Set(4) { 1, '1', NaN, 0 }

Set iki qiymətin «eyni» olduğunu necə müəyyən edir? O, SameValueZero qaydasından istifadə edir: bu, === kimidir, yalnız NaN NaN-a bərabər sayılır (0 və -0 də eynidir). Ona görə 1 və '1' ikisi də qalır, iki NaN isə birə çevrilir. Map açarları da eyni qayda ilə müqayisə edir. Obyektlər və massivlər isə məzmunla yox, istinadla müqayisə olunur: bir-birinə oxşayan iki obyekt iki ayrı qiymətdir, yeni yazılmış [1, 2] massivi isə əvvəlkinə heç vaxt bərabər olmur.

JavaScript
const a = { id: 1 };
const b = { id: 1 };
const people = new Set([a, b, a]);
console.log(people.size);

const ids = new Set([a.id, b.id]);
console.log(ids.size);

const m = new Map();
m.set([1, 2], 'pair');
console.log(m.get([1, 2]));
Gözlənilən nəticə
2
1
undefined

Obyektlərdəki təkrarları silmək üçün Set-ə obyektin özünü yox, primitiv açarını — id, e-poçt — qoy: ids.size 1-dir, çünki 1 ədədi hər iki dəfə eyni qiymətdir. m.get([1, 2]) isə undefined qaytardı, çünki bu, açar kimi saxlanan massiv deyil, yeni massivdir.

Ardıcıllıq, üzərindən keçmə və çevirmələr

Map və Set əlavə olunma sırasını yadda saxlayır və onlardan keçməyin bütün yolları bu sıraya əməl edir. Map üzərində for...of [açar, qiymət] cütləri verir, onları rahatca destrukturlaşdırmaq olur. keys(), values() və entries() iterator qaytarır; massiv metodları lazımdırsa, onları [...] ilə massivə aç. forEach parametrlərinin sırasına diqqət et: massivlərdə olduğu kimi, əvvəl qiymət, sonra açar gəlir.

JavaScript
const prices = new Map([
  ['bread', 0.7],
  ['milk', 1.6],
  ['tea', 4.5],
]);

for (const [item, price] of prices) {
  console.log(`${item}: ${price} AZN`);
}
console.log([...prices.keys()]);
console.log([...prices.values()]);
prices.forEach((value, key) => console.log(key, '->', value));

const tags = new Set(['js', 'css']);
tags.add('html');
for (const tag of tags) console.log(tag);
Gözlənilən nəticə
bread: 0.7 AZN
milk: 1.6 AZN
tea: 4.5 AZN
[ 'bread', 'milk', 'tea' ]
[ 0.7, 1.6, 4.5 ]
bread -> 0.7
milk -> 1.6
tea -> 4.5
js
css
html

Obyektlərdə burada sürpriz var: tam ədədə bənzəyən açarlar həmişə əvvəldə, artan sıra ilə gəlir, qalan açarlar isə yalnız sonra, əlavə olunma sırası ilə. Map isə məhz sənin yazdığın sıranı saxlayır:

JavaScript
const obj = { b: 'first', 2: 'second', 1: 'third' };
console.log(Object.keys(obj));

const map = new Map([['b', 'first'], [2, 'second'], [1, 'third']]);
console.log([...map.keys()]);
Gözlənilən nəticə
[ '1', '2', 'b' ]
[ 'b', 2, 1 ]

Map və Object.entries eyni «dildə» danışır — [açar, qiymət] cütlərindən ibarət massivlə. Ona görə hər çevirmə bir sətirlik işdir: massiv → Set new Set(array), Set → massiv [...set] və ya Array.from(set); obyekt → Map new Map(Object.entries(obj)), Map → obyekt Object.fromEntries(map); Map → cütlər massivi [...map].

JavaScript
const stock = { pen: 12, notebook: 5 };
const stockMap = new Map(Object.entries(stock));
stockMap.set('eraser', 0);
console.log(stockMap);

const back = Object.fromEntries(stockMap);
console.log(back);

console.log(JSON.stringify(stockMap));
console.log(JSON.stringify(Object.fromEntries(stockMap)));
console.log(JSON.stringify([...stockMap]));

const restored = new Map(JSON.parse('[["pen",12],["eraser",0]]'));
console.log(restored.get('pen'));
Gözlənilən nəticə
Map(3) { 'pen' => 12, 'notebook' => 5, 'eraser' => 0 }
{ pen: 12, notebook: 5, eraser: 0 }
{}
{"pen":12,"notebook":5,"eraser":0}
[["pen",12],["notebook",5],["eraser",0]]
12

Çoxluq əməliyyatları: birləşmə, kəsişmə, fərq

Set riyaziyyatdan gəlir, onun əməliyyatları da. 2024-cü ilin ortasından bütün əsas brauzerlərdə və Node.js 22+ versiyalarında bunlar üçün hazır metodlar var (onlar ES2025 standartına daxil olub): union (A ∪ B, birləşmə), intersection (A ∩ B, kəsişmə), difference (A \ B, fərq), symmetricDifference (yalnız birində olanlar), həmçinin isSubsetOf, isSupersetOf və isDisjointFrom yoxlamaları. Hər metod yeni Set qaytarır, mənbə çoxluqları dəyişmir.

JavaScript
const math = new Set(['Aysel', 'Murad', 'Leyla', 'Elvin']);
const informatics = new Set(['Leyla', 'Nigar', 'Murad']);

console.log(math.union(informatics));
console.log(math.intersection(informatics));
console.log(math.difference(informatics));
console.log(math.symmetricDifference(informatics));
console.log(new Set(['Leyla']).isSubsetOf(math));
console.log(math.isDisjointFrom(new Set(['Kamal'])));
Gözlənilən nəticə
Set(5) { 'Aysel', 'Murad', 'Leyla', 'Elvin', 'Nigar' }
Set(2) { 'Leyla', 'Murad' }
Set(2) { 'Aysel', 'Elvin' }
Set(3) { 'Aysel', 'Elvin', 'Nigar' }
true
true

2024-dən əvvəlki brauzerlərdə bu metodlar yoxdur. Eyni nəticəni hər yerdə işləyən filter və has cütü verir, typeof Set.prototype.union yoxlaması isə hansı yolu seçməyi deyir. Bu variant da sürətlidir: informatics.has(name) cəld işləyir, ona görə kəsişmə birinci çoxluq üzərindən bir keçiddə tapılır.

JavaScript
const math = new Set(['Aysel', 'Murad', 'Leyla', 'Elvin']);
const informatics = new Set(['Leyla', 'Nigar', 'Murad']);

const both = [...math].filter((name) => informatics.has(name));
const onlyMath = [...math].filter((name) => !informatics.has(name));
const all = new Set([...math, ...informatics]);

console.log(both);
console.log(onlyMath);
console.log(all.size);
console.log(typeof Set.prototype.union === 'function' ? 'native union available' : 'use the fallback');
Gözlənilən nəticə
[ 'Murad', 'Leyla' ]
[ 'Aysel', 'Elvin' ]
5
native union available

WeakMap və WeakSet

Zəif istinadTərif

WeakMap və WeakSet açarlarını zəif saxlayır: proqramın başqa heç bir yeri açar obyektinə istinad etmirsə, zibil yığıcı onu silə bilər və onun elementi də kolleksiyadan yox olur.

Ona görə qaydalar Map və Set-dəkindən fərqlidir: açar yalnız obyekt (və qeydiyyatdan keçməmiş simvol) ola bilər; size, clear() və üzərindən keçmək yoxdur — məzmun istənilən an yox ola bildiyi üçün dil onun siyahısını verməyə icazə vermir. Yalnız set/get/has/delete qalır (WeakSet-də add/has/delete). Tipik istifadə: sənə aid olmayan obyektlərə (DOM elementləri, kitabxana obyektləri) əlavə məlumat və ya keş bağlamaq, obyektləri «artıq emal olunub» kimi işarələmək. Obyekt yox olanda məlumat da onunla gedir və yaddaş sızmır.

JavaScript
const processed = new WeakSet();
const cache = new WeakMap();

function total(cart) {
  if (cache.has(cart)) return cache.get(cart) + ' (from cache)';
  const sum = cart.items.reduce((s, item) => s + item.price, 0);
  cache.set(cart, sum);
  return sum;
}

let cart = { items: [{ price: 4.5 }, { price: 1.6 }] };
console.log(total(cart));
console.log(total(cart));

processed.add(cart);
console.log(processed.has(cart), processed.has({ ...cart }));

try {
  cache.set('cart-1', 10);
} catch (error) {
  console.log(error.name);
}
console.log(cache.size, typeof cache.keys);
cart = null;
Gözlənilən nəticə
6.1
6.1 (from cache)
true false
TypeError
undefined undefined

Tipik tapşırıqlar və mini layihə

Proqramçıların Map və Set ilə ən çox həll etdiyi üç iş var: saymaq, təkrarları silmək və qruplaşdırmaq. Saymaq alqoritmi həmişə eynidir:

  1. Boş Map yarat

    const counts = new Map(); — açar sayılan şeydir, qiymət onun sayı.

  2. Hər element üçün açarı tap

    Söz, şəhər, qiymət — nəyi sayırsansa.

  3. Sayğacı artır

    counts.set(key, (counts.get(key) ?? 0) + 1) — açar yoxdursa, ?? 0 sıfırdan başladır.

  4. Nəticəni oxu və ya sırala

    [...counts].sort((a, b) => b[1] - a[1]) ən çox rast gələnləri əvvələ çıxarır.

JavaScript
const text = 'the cat and the dog and the bird';
const freq = new Map();
for (const word of text.split(' ')) {
  freq.set(word, (freq.get(word) ?? 0) + 1);
}
console.log(freq);

const top = [...freq].sort((x, y) => y[1] - x[1]).slice(0, 2);
console.log(top);
Gözlənilən nəticə
Map(5) { 'the' => 3, 'cat' => 1, 'and' => 2, 'dog' => 1, 'bird' => 1 }
[ [ 'the', 3 ], [ 'and', 2 ] ]

Qruplaşdırma da eyni fikirdir, yalnız qiymət massivdir: açar yoxdursa, boş massiv yarat, sonra elementi ona əlavə et. ES2024-dən bəri bunun hazır variantı da var: Map.groupBy(items, fn) (və nəticəni obyekt kimi verən Object.groupBy).

JavaScript
const students = [
  { name: 'Aysel', city: 'Baku' },
  { name: 'Murad', city: 'Ganja' },
  { name: 'Leyla', city: 'Baku' },
  { name: 'Elvin', city: 'Shaki' },
];

const byCity = new Map();
for (const s of students) {
  if (!byCity.has(s.city)) byCity.set(s.city, []);
  byCity.get(s.city).push(s.name);
}
for (const [city, names] of byCity) console.log(city, names);

const grouped = Map.groupBy(students, (s) => s.city);
console.log(grouped.get('Baku').length, [...grouped.keys()]);
Gözlənilən nəticə
Baku [ 'Aysel', 'Leyla' ]
Ganja [ 'Murad' ]
Shaki [ 'Elvin' ]
2 [ 'Baku', 'Ganja', 'Shaki' ]

İndi dərsin əvvəlindəki olimpiada tapşırığını həll edək. email|fənn açarlarından ibarət Set təkrar qeydiyyatları atır, Map hər şəhər üzrə qeydiyyatları sayır, «fənn → adlar Set-i» Map-i isə hər fənnin iştirakçılarını toplayır; iki Set-in kəsişməsi hər iki fənnə yazılanları verir.

JavaScript
const registrations = [
  { email: 'aysel@mail.az', name: 'Aysel', city: 'Baku', subject: 'math' },
  { email: 'murad@mail.az', name: 'Murad', city: 'Ganja', subject: 'math' },
  { email: 'aysel@mail.az', name: 'Aysel', city: 'Baku', subject: 'math' },
  { email: 'leyla@mail.az', name: 'Leyla', city: 'Baku', subject: 'it' },
  { email: 'murad@mail.az', name: 'Murad', city: 'Ganja', subject: 'it' },
  { email: 'nigar@mail.az', name: 'Nigar', city: 'Shaki', subject: 'it' },
];

const seen = new Set();
const bySubject = new Map();
const perCity = new Map();
for (const r of registrations) {
  const key = `${r.email}|${r.subject}`;
  if (seen.has(key)) continue;
  seen.add(key);
  if (!bySubject.has(r.subject)) bySubject.set(r.subject, new Set());
  bySubject.get(r.subject).add(r.name);
  perCity.set(r.city, (perCity.get(r.city) ?? 0) + 1);
}

console.log('unique registrations:', seen.size);
console.log(perCity);
console.log('both subjects:', [...bySubject.get('math').intersection(bySubject.get('it'))]);
Gözlənilən nəticə
unique registrations: 5
Map(3) { 'Baku' => 2, 'Ganja' => 2, 'Shaki' => 1 }
both subjects: [ 'Murad' ]

Aysel iki dəfə eyni fənnə yazıldığı üçün altı qeydiyyatdan beşi qaldı. Murad isə iki fərqli fənnə yazılıb — bu, təkrar deyil, ona görə açara fənn də daxildir. Aşağıdakı kod tez-tez rast gələn iki səhvi göstərir.

JavaScript
console.log(new Set('hello'));
console.log(new Set(['hello']));

const map = new Map();
map['Baku'] = 2300000;
console.log(map.size, map.get('Baku'));
Gözlənilən nəticə
Set(4) { 'h', 'e', 'l', 'o' }
Set(1) { 'hello' }
0 undefined

Tapşırıq

grades massivində hər qiymətin neçə dəfə rast gəldiyini Map ilə say və hər elementi ilk görünmə sırası ilə qiymət: say şəklində çap et.

Tapşırıq · JavaScript
const grades = [5, 4, 5, 3, 5, 4];
const counts = new Map();
// count each mark, then print "mark: count" lines
Gözlənilən nəticə
5: 3
4: 2
3: 1

Tapşırıq

Ayselin və Muradın dost siyahılarında təkrarlar var. Üç sətir çap et: 1) Ayselin unikal dostlarının sayı; 2) ortaq dostlar — əlifba sırası ilə massiv; 3) yalnız Ayselin dostları — əlifba sırası ilə massiv. Köhnə brauzerlərdə də işləsin deyə filter və has işlət.

Tapşırıq · JavaScript
const aysel = ['Leyla', 'Elvin', 'Nigar', 'Leyla', 'Kamal'];
const murad = ['Elvin', 'Orxan', 'Kamal', 'Elvin'];
// 1) unique count  2) common, sorted  3) only Aysel, sorted
Gözlənilən nəticə
4
[ 'Elvin', 'Kamal' ]
[ 'Leyla', 'Nigar' ]

Yadda saxla

  • Map — istənilən tipdə açarı olan «açar → qiymət» kolleksiyası: set/get/has/delete, size, əlavə olunma sırası, miras açar yoxdur.
  • Set unikal qiymətləri SameValueZero qaydası ilə saxlayır; [...new Set(arr)] təkrarları silir, obyektlər isə istinadla müqayisə olunur.
  • Çevirmələr cütlər massivi ilə gedir: new Map(Object.entries(obj)), Object.fromEntries(map), [...map]; JSON.stringify(map) {} verir.
  • union, intersection, difference, symmetricDifference (ES2025) yeni Set qaytarır; köhnə brauzerlər üçün filter + has.
  • WeakMap/WeakSet obyekt açarlarını zəif saxlayır: size və üzərindən keçmək yoxdur; obyektlərə bağlı keş və işarələr üçündür.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. Nə çap olunur?
const m = new Map(); m.set('a', 1).set('a', 2); console.log(m.size, m.get('a'));