Bu materyal This madde henüz sadece: dillerinde mevcuttur. Lütfen bize bu bölümün çevirisini Türkçe çevirmek için yardım ediniz.

Map, Set, WeakMap and WeakSet

Now we know the following complex data structures:

  • Objects for storing keyed collections.
  • Arrays for storing ordered collections.

But that’s not enough for real life. That’s why there also exist Map and Set.


Map is a collection of keyed data items. Just like an Object. But the main difference is that Map allows keys of any type.

The main methods are:

  • new Map() – creates the map.
  • map.set(key, value) – stores the value by the key.
  • map.get(key) – returns the value by the key, undefined if key doesn’t exist in map.
  • map.has(key) – returns true if the key exists, false otherwise.
  • map.delete(key) – removes the value by the key.
  • map.clear() – clears the map
  • map.size – is the current elements count.

For instance:

let map = new Map();

map.set('1', 'str1');   // a string key
map.set(1, 'num1');     // a numeric key
map.set(true, 'bool1'); // a boolean key

// remember the regular Object? it would convert keys to string
// Map keeps the type, so these two are different:
alert( map.get(1)   ); // 'num1'
alert( map.get('1') ); // 'str1'

alert( map.size ); // 3

As we can see, unlike objects, keys are not converted to strings. Any type of key is possible.

Map can also use objects as keys.

For instance:

let john = { name: "John" };

// for every user, let's store his visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Using objects as keys is one of most notable and important Map features. For string keys, Object can be fine, but it would be difficult to replace the Map with a regular Object in the example above.

In the old times, before Map existed, people added unique identifiers to objects for that:

// we add the id field
let john = { name: "John", id: 1 };

let visitsCounts = {};

// now store the value by id
visitsCounts[john.id] = 123;

alert( visitsCounts[john.id] ); // 123

…But Map is much more elegant.

How Map compares keys

To test values for equivalence, Map uses the algorithm SameValueZero. It is roughly the same as the strict equality ===, but the difference is that NaN is considered equal to NaN. So NaN can be used as the key as well.

This algorithm can’t be changed or customized.


Every map.set call returns the map itself, so we can “chain” the calls:

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

Map from Object

When a Map is created, we can pass an array (or another iterable) with key-value pairs, like this:

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']

There is a built-in method Object.entries(obj) that returns the array of key/value pairs for an object exactly in that format.

So we can initialize a map from an object like this:

let map = new Map(Object.entries({
  name: "John",
  age: 30

Here, Object.entries returns the array of key/value pairs: [ ["name","John"], ["age", 30] ]. That’s what Map needs.

Iteration over Map

For looping over a map, there are 3 methods:

  • map.keys() – returns an iterable for keys,
  • map.values() – returns an iterable for values,
  • map.entries() – returns an iterable for entries [key, value], it’s used by default in for..of.

For instance:

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]

// iterate over keys (vegetables)
for(let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomateos, onion

// iterate over values (amounts)
for(let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50

// iterate over [key, value] entries
for(let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
The insertion order is used

The iteration goes in the same order as the values were inserted. Map preserves this order, unlike a regular Object.

Besides that, Map has a built-in forEach method, similar to Array:

recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc


Set – is a collection of values, where each value may occur only once.

The main methods are:

  • new Set(iterable) – creates the set, optionally from an array of values (any iterable will do).
  • set.add(value) – adds a value, returns the set itself.
  • set.delete(value) – removes the value, returns true if value existed at the moment of the call, otherwise false.
  • set.has(value) – returns true if the value exists in the set, otherwise false.
  • set.clear() – removes everything from the set.
  • set.size – is the elements count.

For example, we have visitors coming, and we’d like to remember everyone. But repeated visits should not lead to duplicates. A visitor must be “counted” only once.

Set is just the right thing for that:

let set = new Set();

let john = { name: "John" };
let pete = { name: "Pete" };
let mary = { name: "Mary" };

// visits, some users come multiple times

// set keeps only unique values
alert( set.size ); // 3

for(let user of set) {
  alert(user.name); // John (then Pete and Mary)

The alternative to Set could be an array of users, and the code to check for duplicates on every insertion using arr.find. But the performance would be much worse, because this method walks through the whole array checking every element. Set is much better optimized internally for uniqueness checks.

Iteration over Set

We can loop over a set either with for..of or using forEach:

let set = new Set(["oranges", "apples", "bananas"]);

for(let value of set) alert(value);

// the same with forEach:
set.forEach((value, valueAgain, set) => {

Note the funny thing. The forEach function in the Set has 3 arguments: a value, then again a value, and then the target object. Indeed, the same value appears in the arguments twice.

That’s made for compatibility with Map where forEach has three arguments.

The same methods as Map has for iterators are also supported:

  • set.keys() – returns an iterable object for values,
  • set.values() – same as set.keys, for compatibility with Map,
  • set.entries() – returns an iterable object for entries [value, value], exists for compatibility with Map.

WeakMap and WeakSet

WeakSet is a special kind of Set that does not prevent JavaScript from removing its items from memory. WeakMap is the same thing for Map.

As we know from the chapter Çöp Toplama ( Garbage collection ), JavaScript engine stores a value in memory while it is reachable (and can potentially be used).

For instance:

let john = { name: "John" };

// the object can be accessed, john is the reference to it

// overwrite the reference
john = null;

// the object will be removed from memory

Usually, properties of an object or elements of an array or another data structure are considered reachable and kept in memory while that data structure is in memory.

In a regular Map, it does not matter if we store an object as a key or as a value. It’s kept in memory even if there are no more references to it.

For instance:

let john = { name: "John" };

let map = new Map();
map.set(john, "...");

john = null; // overwrite the reference

// john is stored inside the map
// we can get it by using map.keys()

With the exception of WeakMap/WeakSet.

WeakMap/WeakSet does not prevent the object removal from the memory.

Let’s start with WeakMap.

The first difference from Map is that its keys must be objects, not primitive values:

let weakMap = new WeakMap();

let obj = {};

weakMap.set(obj, "ok"); // works fine (object key)

weakMap.set("test", "Whoops"); // Error, because "test" is a primitive

Now, if we use an object as the key in it, and there are no other references to that object – it will be removed from memory (and from the map) automatically.

let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // overwrite the reference

// john is removed from memory!

Compare it with the regular Map example above. Now if john only exists as the key of WeakMap – it is to be automatically deleted.

…And WeakMap does not support methods keys(), values(), entries(), we can not iterate over it. So there’s really no way to receive all keys or values from it.

WeakMap has only the following methods:

  • weakMap.get(key)
  • weakMap.set(key, value)
  • weakMap.delete(key, value)
  • weakMap.has(key)

Why such a limitation? That’s for technical reasons. If the object has lost all other references (like john in the code above), then it is to be deleted automatically. But technically it’s not exactly specified when the cleanup happens.

The JavaScript engine decides that. It may choose to perform the memory cleanup immediately or to wait and do the cleaning later when more deletions happen. So, technically the current element count of the WeakMap is not known. The engine may have cleaned it up or not, or did it partially. For that reason, methods that access WeakMap as a whole are not supported.

Now where do we need such thing?

The idea of WeakMap is that we can store something for an object that exists only while the object exists. But we do not force the object to live by the mere fact that we store something for it.

weakMap.put(john, "secret documents");
// if john dies, secret documents will be destroyed

That’s useful for situations when we have a main storage for the objects somewhere and need to keep additional information that is only relevant while the object lives.

Let’s see an example.

For instance, we have a code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don’t want to store his visit count any more.

One way would be to keep track of leaving users and clean up the storage manually:

let john = { name: "John" };

// map: user => visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

// now john leaves us, we don't need him any more
john = null;

// but it's still in the map, we need to clean it!
alert( visitsCountMap.size ); // 1
// it's also in the memory, because Map uses it as the key

Another way would be to use WeakMap:

let john = { name: "John" };

let visitsCountMap = new WeakMap();

visitsCountMap.set(john, 123);

// now john leaves us, we don't need him any more
john = null;

// there are no references except WeakMap,
// so the object is removed both from the memory and from visitsCountMap automatically

With a regular Map, cleaning up after a user has left becomes a tedious task: we not only need to remove the user from its main storage (be it a variable or an array), but also need to clean up the additional stores like visitsCountMap. And it can become cumbersome in more complex cases when users are managed in one place of the code and the additional structure is at another place and is getting no information about removals.

WeakMap can make things simpler, because it is cleaned up automatically. The information in it like visits count in the example above lives only while the key object exists.

WeakSet behaves similarly:

  • It is analogous to Set, but we may only add objects to WeakSet (not primitives).
  • An object exists in the set while it has reachable from somewhere else.
  • Like Set, it supports add, has and delete, but not size, keys() and no iterations.

For instance, we can use it to keep track of whether an item is checked:

let messages = [
    {text: "Hello", from: "John"},
    {text: "How goes?", from: "John"},
    {text: "See you soon", from: "Alice"}

// fill it with array elements (3 items)
let unreadSet = new WeakSet(messages);

// we can use unreadSet to see whether a message is unread
alert(unreadSet.has(messages[1])); // true
// remove it from the set after reading
unreadSet.delete(messages[1]); // true

// and when we shift our messages history, the set is cleaned up automatically
// no need to clean unreadSet, it now has 2 items
// unfortunately, there's no method to get the exact count of items, so can't show it

The most notable limitation of WeakMap and WeakSet is the absence of iterations, and inability to get all current content. That may appear inconvenient, but actually does not prevent WeakMap/WeakSet from doing their main job – be an “additional” storage of data for objects which are stored/managed at another place.


  • Map – is a a collection of keyed values.

    The differences from a regular Object:

    • Any keys, objects can be keys.
    • Iterates in the insertion order.
    • Additional convenient methods, the size property.
  • Set – is a collection of unique values.

    • Unlike an array, does not allow to reorder elements.
    • Keeps the insertion order.
  • WeakMap – a variant of Map that allows only objects as keys and removes them once they become unaccessible by other means.

    • It does not support operations on the structure as a whole: no size, no clear(), no iterations.
  • WeakSet – is a variant of Set that only stores objects and removes them once they become unaccessible by other means.

    • Also does not support size/clear() and iterations.

WeakMap and WeakSet are used as “secondary” data structures in additional to the “main” object storage. Once the object is removed from the main storage, so it only stays in WeakMap/WeakSet, they clean up aumatically.


önem: 5

arr adında bir diziniz olsun.

essiz(dizi) adında bir fonksiyon yazınız bu fonksiyon dizi'nin eşsiz elemanlarını dönmelidir.


function essiz(arr) {
  /* kodunuz */

let kullanicilar = ["Emine", "Muzaffer", "Fatma", "Kanako",
  "Kanako", "Muzaffer", "Fatma", "Kanako", ":-O"

alert( benzersiz(kullanicilar) ); // Emine, :-O

Not: Burada karakterler kullanıldı fakat bunun yerine her tip olabilir. Not: Eşsiz değerler için Set kullanabilirsiniz.

Testler ile korunaklı olan aç.

önem: 4

Anagramlar aynı sayıda harfi olan aynı harflere sahip kelime demektir. Dizilimleri farklı olmalıdır.


aks, ask, kas, sak
alim, amil, ilam, imal, imla, mail, mali
açlık, akçıl, çakıl, çalık, çalkı, kaçlı, kalıç, lakç

atemiz(dizi) adında bir fonksiyon yazın ve bu fonksiyon diziyi anagramlardan temizlesin.


let arr = ["aks", "alim", "açlık", "ask", "ilam", "çalık"];

alert( aclean(arr) ); // "aks,alim,açlık" veya "ask,ilam,çalık"

Hangisi olduğuna bakılmaksızın her anagram grubunda bir tane kelime kalmalıdır. Hangisinin olduğu önemli değildir.

Testler ile korunaklı olan aç.

Tüm anagramları bulmak için öncelikle kelimeleri harflerine ayırıp sonrasında sıralamak gerekmektedir.


aks, ask, kas, sak
alim, amil, ilam, imal, imla, mail, mali
açlık, akçıl, çakıl, çalık, çalkı, kaçlı, kalıç, lakç

Harf sıralı tipler map anahtarları olacak şekilde kaydedilir.

function atemiz(dizi) {
  let map = new Map();

  for(let word of dizi) {
    // kelimeyi harflere ayır, sonrasında birleştir.
    let sorted = word.toLowerCase().split('').sort().join(''); // (*)
    map.set(sorted, word);

  return Array.from(map.values());

let arr = ["aks", "alim", "açlık", "ask", "ilam", "çalık"];

alert( atemiz(arr) );

Harflerin sıralanması (*)'da gösterilen zincirleme çağrılar ile yapılır.

Daha kolay anlaşılabilmesi için bunu satırlara ayıralım:

let sorted = arr[i] // AKS
  .toLowerCase() // aks
  .split('') // ['a','k','s']
  .sort() // ['a','k','s']
  .join(''); // aks

İki farklı kelime 'AKS' ve 'ASK' sıralandığında ikisi de 'AKS' olmaktadır.

Bir sonraki satır bu kelimeleri map’e eklemeye yarar:

map.set(sorted, word);

Eğer aynı karakterlere sahip kelime ile tekrar karşılaşılırsa, map olduğundan dolayı bir öncekinin üzerine yazılacaktır. Bundan dolayı her zaman bir karakter-form’u için maksimum bir tane kelimeye sahip olacağız.

Sonunda Array.from(map.values()) bu map değerleri üzerinden döngü yapılmasını sağlar.

Burada Map yerine normal obje de kullanılabilirdi. Çünkü anahtarlar karakter dizisi olacak.

Bu durumda çözüm şu şekilde olabilir:

function atemiz(dizi) {
  let obj = {};

  for (let i = 0; i < dizi.length; i++) {
    let sorted = dizi[i].toLowerCase().split("").sort().join("");
    obj[sorted] = dizi[i];

  return Array.from(Object.values(obj));

let arr = ["aks", "alim", "açlık", "ask", "ilam", "çalık"];

alert( atemiz(arr) );

Çözümü testler korunaklı alanda olacak şekilde aç.

önem: 5

map.keys() dizisini alıp bunun ile uğraşmak istenmekte.

Fakat bir problem var:

let map = new Map();

map.set("adi", "Abdullah");

let keys = map.keys();

// Error: numbers.push adında bir fonksiyon bulunmamaktadır.
keys.push("daha fazla");

Neden? keys.push kodunu nasıl düzeltebilirsiniz?

Çünkü map.keys() sıralı erişim objesi ( iterable ) döndürüyor. push metodu dizi'lere ait bir metoddur.

Array.from ile bunu diziye çevirebilirsiniz:

let map = new Map();

map.set("adi", "Abdullah");

let keys = Array.from(map.keys());

keys.push("daha fazla");

alert(keys); // adi, daha fazla
önem: 5

Mesajların bulunduğu bir dizi düşünün:

let mesajlar = [
    {metin: "Merhaba", kimden: "Ahmet"},
    {metin: "Nasıl Gidiyor?", kimden: "Ahmet"},
    {metin: "Sonra görüşürüz", kimden: "Mehmet"}

Kodunuz bu diziye erişebilir, fakat mesajlar başkasının koduyla yönetiliyor. Yeni mesajların eklenmesi, eskilerin silinmesi gibi olayların ne zaman olduğunu bilmiyorsunuz.

Peki “okunmuş mesajlar”'ı bulabilmek için ne tür bir veri yapısı kullanmanız gerekmektedir? Bu yapı “okundu mu?” sorusuna doğru bir şekilde cevap verebilmeli.

Not: mesajlar'dan herhangi bir mesaj silindiğinde sizin yapınızda da bu mesaj silinmelidir.

Not: Mesaj objesini doğrudan değiştirmemelisiniz. Başkasının kodu olduğundan ekstra özellikler beklenmeyen sorunlara neden olabilir.

En mantıklı çözüm WeakSet'tir.

let mesajlar = [
    {metin: "Merhaba", kimden: "Ahmet"},
    {metin: "Nasıl Gidiyor?", kimden: "Ahmet"},
    {metin: "Sonra görüşürüz", kimden: "Mehmet"}

let okunanlar = new WeakSet();

// iki mesaj okundu
// okunanlar'ın iki elemanı var.

// ... Birincisi tekrar okunursa
// okunanlar hala 2 tane eşsiz elemana sahip

// cevapla:mesajlar[0] okundu mu?
alert("Read message 0: " + okunanlar.has(mesajlar[0])); // true

// şimdi mesajların 1 elemanı var ( teknik olarak hafıza daha sonra silinebilir)

WeakSetmesajların saklanmasını ve içinde aranan mesajların olup olmadığını söyleyebilecek bir mekanizmadır.

Kendini otomatik olarak temizler. Burada karşılaşılan zorluk döngüye girmemesidir. “tüm okunan mesajlar”'ı doğrudan gösteremez. Fakat bunu diziyi döngüye sokup sonrasında bu WeakSet'te olanları filtreleyerek çözebilirsiniz.

Not: Her mesaja kendi özelliğimizi eklemek eğer mesajlar dizisi başkası tarafından yönetiliyor ise tehlikeli olabilir, fakat bunu özmek için symbol kullanılabilir.

Aşağıdaki gibi:

// symbolic özellikler sadece bizim kodumuz tarafından bilinir.
let okunduMu = Symbol("okunduMu");
mesajlar[0][okunduMu] = true;

Şimdi eğer başkası for..in ile mesajlar dizisini dönmeye çalışsa bile gizli olarak eklediğimiz okunduMu görünmeyecektir.

önem: 5

öncegi görevde mesaj dizisi vardı. Burada da durum ona benzer.

let mesajlar = [
    {metin: "Merhaba", kimden: "Ahmet"},
    {metin: "Nasıl Gidiyor?", kimden: "Ahmet"},
    {metin: "Sonra görüşürüz", kimden: "Mehmet"}

Şimdiki soru: Mesajın “ne zaman okunduğunu tutmak için” hangi veri yapısını önerirsiniz.

Bir önceki görevde sadece “evet/hayır” tutmanız gerekmişti. Şimdi ise “ne zaman” bilgisinin tutulması gerekir, aynı şekilde eğer mesajlardan silindiğinde sizin oluşturduğunuz yapıdan da silinmesi gerekir.

Date ( tarih ) objesini tutmak için yine WeakMap kullanabilirsiniz.

let mesajlar = [
    {metin: "Merhaba", kimden: "Ahmet"},
    {metin: "Nasıl Gidiyor?", kimden: "Ahmet"},
    {metin: "Sonra görüşürüz", kimden: "Mehmet"}

let readMap = new WeakMap();

readMap.set(messages[0], new Date(2017, 1, 1));
// Date(tarih) objesini ilerleyen konularda göreceksiniz.
Eğitim haritası


yorum yapmadan önce lütfen okuyun...
  • Eğer geliştirme ile alakalı bir öneriniz var ise yorum yerine github konusu gönderiniz.
  • Eğer makalede bir yeri anlamadıysanız lütfen belirtiniz.
  • Koda birkaç satır eklemek için <code> kullanınız, birkaç satır eklemek için ise <pre> kullanın. Eğer 10 satırdan fazla kod ekleyecekseniz plnkr kullanabilirsiniz)