Map, Set, WeakMap ve WeakSet

Şu ana kadar bu karmaşık veri yapılarını gördük:

• Anahtar deÄŸere sahip verileri tutan objeler.
• Sıralı bir biçimde verileri tutan Diziler.

Ancak bunlar yeterli olmayabiliyorlar. Bu yüzden Map ve Set diye yapılar bulunuyor. (Collections)

Map

Map, anahtar deÄŸere sahip veriler tutan bir yapıdır (collection). Tıpkı Obje gibi. Fakat aralarındaki en önemli farklardan biri Mapler anahtar deÄŸer olarak herhangi bir tipte olabilirler.

Ana fonksiyonlar ÅŸu ÅŸekildedir:

• new Map() – map yaratır.
• map.set(key, value) – Anahtara deÄŸer atar.
• map.get(key) – Anahtarın deÄŸerini döndürür. EÄŸer öyle bir anahtar yoksa undefined döndürür.
• map.has(key) – EÄŸer öyle bir anahtar varsa true yoksa false döndürür.
• map.delete(key) – Verilen anahtara ait deÄŸeri siler.
• map.clear() – Mapin içini temizler.
• map.size – anlık eleman sayısını döndürür.

Örneğin:

let map = new Map();

map.set('1', 'str1');   // String tipinde anahtar
map.set(1, 'num1');     // Sayı tipinde anahtar
map.set(true, 'bool1'); // boolean tipinde anahtar

// sıradan Objeleri hatırlıyorsunuzdur. Anahtar değerleri stringe dönüşürdü
// Map anahtar tipini de korur, tıpkı şu 2 farklı şekilde olduğu gibi:
alert( map.get(1)   ); // 'num1'
alert( map.get('1') ); // 'str1'

alert( map.size ); // 3

Gördüğümüz üzere, objelerden farklı olarak, anahtarlar stringe dönüşmediler. Herhangi bir tipte anahtar kullanmak mümkündür.

Map’ler ayrıca anahtar olarak Obje de kullanabilir.

Örneğin:

let john = { name: "John" };

// John'un ziyaret sayısını tutalım
let ziyaretSayisiMap = new Map();

// john map için anahtar olarak kullanıldı
ziyaretSayisiMap.set(john, 123);

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

Nesneleri anahtar olarak kullanmak, en dikkate deÄŸer ve önemli Map özelliklerinden biridir. String anahtarlar için Obje yeterli olabilir fakat yukarıdaki örnek için Map yerine Obje kullanmak daha zordur.

Eskiden, Mapin olmadığı zamanlarda, geliÅŸtiriciler objelere eÅŸsiz tanımlayıcılar eklerdi:

// id deÄŸeri ekledik
let john = { name: "John", id: 1 };

let ziyaretSayisi = {};

// ÅŸimdi id kullanarak veriyi tuttuk
ziyaretSayisi[john.id] = 123;

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

ziyaretSayisi bir nesne olduğundan, John gibi tüm anahtarları dizelere dönüştürür, bu nedenle “[object Object]” dize anahtarına sahibiz.

…Ama Map kullanması çok daha hoÅŸ.

Map anahtarları nasıl karşılaÅŸtırır"

DeÄŸerlerin eÅŸitliÄŸini test etmek için ‘Map’ SameValueZero algoritmasını kullanır. Bu algoritma sıkı eÅŸitlik === ile kabaca aynıdır fakat farkı NaNın NaNa eÅŸit olmasıdır. Böylece NaN bir anahtar deÄŸer olarak kullanılabilir.

Bu algoritma değiştirilemez veya özelleştirilemez.

````"Zincirleme"

Tüm `map.set` çağırmaları mapin kendisini döndürür. Böylece çağırmaları `zincir`leyebiliriz:

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

Objeden Map

Bir Map oluÅŸturduÄŸumuzda anahtar-deÄŸer çifti olarak dizi kullanabiliriz:

// [key, value] çiftlerinden oluşan dizi
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

Tıpkı bu formatta objeler için anahtar/değer çifti dizisi döndüren bir yerleşik fonksiyon Object.entries(obj) vardır.

Böylece bir objeden bir map oluşturabiliriz:

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

Burada, Object.entries anahtar/deÄŸer çifti dizisi döndürür: [ ["name","John"], ["age", 30] ]. Mapin ihtiyacı olan da buydu.

Map üzerinde yineleme

Map üzerinde döngü yapmak için 3 metod vardır:

• map.keys() – anahtarlar için bir yinelenebilir döndürür.
• map.values() – deÄŸerler için bir yinelenebilir döndürür.
• map.entries() – [key, value] giriÅŸleri için bir yinelenebilir döndürür, for..of içinde varsayılan olarak kullanılır.

Örneğin:

let yemekMap = new Map([
  ['salatalik', 500],
  ['domates', 350],
  ['sogan',    50]
]);

// anahtarlar üzerinde yineleme (sebzeler)
for(let vegetable of yemekMap.keys()) {
  alert(vegetable); // salatalik, domates, sogan
}

// değerler üzerinde yineleme (miktarlar)
for(let amount of yemekMap.values()) {
  alert(amount); // 500, 350, 50
}

// [anahtar, değer] üzerinde yineleme
for(let entry of yemekMap) { // yemekMap.entries() ile aynı
  alert(entry); // salatalik,500 (vb.)
}

Bunun yanı sıra, Map yerleÅŸik forEach metoduna sahiptir, tıpkı Dizi gibi:

yemekMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // salatalik: 500 vb.
});

Set

Set her deÄŸerin sadece birer kez olabileceÄŸi yapılardır (collection).

Ana fonksiyonlar ÅŸu ÅŸekildedir:

• new Set(iterable) – set oluÅŸturur, isteÄŸe baÄŸlı olarak deÄŸerler içeren diziden de oluÅŸturulabilir.
• set.add(value) – bir deÄŸer ekler, set’in kendisini döndürür
• set.delete(value) – deÄŸeri siler. EÄŸer öyle bir deÄŸer varsa true yoksa false döndürür.
• set.has(value) – EÄŸer öyle bir deÄŸer varsa true yoksa false döndürür.
• set.clear() – set’in içindeki her ÅŸeyi siler.
• set.size – eleman sayısını döndürür.

Örneğin, misafirlerimiz geliyor ve herkesi hatırlamak istiyoruz. Fakat ikinci defa gelenlerin tekrarlanmasını istemiyoruz. Bir ziyaretçinin sadece bir kez “sayılması” gerekiyor.

Set tam olarak ihtiyacımız olan ÅŸey:

let set = new Set();

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

// ziyaretler, bazıları birden çok kez gelmiş
set.add(john);
set.add(pete);
set.add(mary);
set.add(john);
set.add(mary);

// set sadece eÅŸsiz deÄŸerler tutar
alert( set.size ); // 3

for(let user of set) {
  alert(user.name); // John (sonraki döngülerde Pete and Mary)
}

Kullanıcılardan oluÅŸan bir dizi Sete alternatif olabilir ve arr.find kullanarak her ekleme yaparken aynısından var mı diye kontrol yapabiliriz. Fakat bu kodumuzun performansını azaltır. Çünkü bu metod ile her seferinde dizinin tüm elemanlarını kontrol etmemiz gerekir. Set eÅŸsizlik kontrolü yapmak için daha iyi optimize edilmiÅŸtir.

Set üzerinde yineleme

‘for…of’ veya ‘forEach’ kullanarak set üzerinde yineleme yapmamız mümkündür:

let set = new Set(["portakal", "elma", "muz"]);

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

// forEach ile de aynı şekilde:
set.forEach((value, valueAgain, set) => {
  alert(value);
});

Komiktir ki Set içerisindeki forEach` fonksiyonu 3 argümana sahiptir: bir deÄŸer, sonra tekrardan bir deÄŸer, ve hedef obje. Aslında aynı deÄŸeri argümanda 2 kez görürüz.

Bu, 3 argüman alan forEach fonksiyonuna sahip olan Map ile uyumlu olması için yapılmıştır.

Mapin sahip olduÄŸu yineleme yapan fonksiyonlar burada da vardır:

• set.keys() – deÄŸerler için bir yinelenebilir nesne döndürür,
• set.values() – set.keys ile aynı, Map ile uyumlu olması için yapılmış,
• set.entries() – [value, value] giriÅŸleri için yinelenebilir obje döndürür, Map ile uyumlu olması için vardır.

WeakMap and WeakSet

WeakSet, JavaScript’in WeakSet’teki ögeleri bellekten kaldırmasını engellemeyen özel bir tür Set dir. WeakMap de Map için aynı ÅŸeydir.

Çöp Toplama ( Garbage collection ) konusundan bildiğimiz üzere, JavaScript motoru bir değeri ona erişebildiği(ve potansiyel olarak kullanılabildiği) sürece bellekte tutar.

Örneğin:

let john = { name: "John" };

// Obje erişebilir, john da onun referansı

// referansın üzerine yazalım (overwrite)
john = null;

// obje daha fazla erişebilir olmadığı için bellekten silinir.

Genellikle, bir veri yapısı hafızada bulunduğu sürece onun ögelerine (bir objenin özelliklerine veya bir dizinin elamanlarına) ulaşılabilir ve hafızada tutulabilir kabul edilir.

Normal Mapte bir objeyi anahtar veya deÄŸer olarak tutmamızın bir önemi yoktur. BaÅŸka referansı olmasa bile bellekte tutulur.

Örneğin:

let john = { name: "John" };

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

john = null; // referansın üzerine yazalım (overwrite)

// john map içinde tutuldu
// map.keys() kullanarak ona ulaÅŸabiliriz

WeakMap/WeakSet istisnası olarak.

WeakMap/WeakSet nesnenin bellekten kaldırılmasını engellemez.

WeakMap ile baÅŸlayalım.

Mapten ilk farkı, anahtarlar obje olmalı, ilkel tipte olamaz.

let weakMap = new WeakMap();

let obj = {};

weakMap.set(obj, "ok"); // düzgün çalışır (anahtar bir obje)

weakMap.set("test", "Whoops"); // Hata verir, çünkü "test" ilkel bir tipte

Şimdi, bir nesneyi anahtar olarak kullanırsak ve o nesneye başka referanslar yoksa – otomatik olarak bellekten (ve mapten) kaldırılır.

let john = { name: "John" };

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

john = null; // referansın üzerine yazalım (overwrite)

// john bellekten silindi!

Yukarıdaki normal Map örneÄŸiyle karşılaÅŸtırın. Åžimdi eÄŸer john sadece WeakMap anahtarı olarak var olduysa – otomatik olarak silinir.

…Ve WeakMap keys(), values(), entries() metodlarını desteklemez, yineleme yapamayız. Bu yüzden tüm anahtar veya deÄŸerleri çekmemizin bir yolu yoktur.

WeakMap sadece bu metodlara sahiptir:

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

Neden böyle bir sınırlama var? Teknik sebeplerden dolayı. Nesne diğer tüm referansları (yukarıdaki koddaki john gibi) kaybetmişse, otomatik olarak silinecektir. Ancak teknik olarak, temizleme işlemi yapılırken tam olarak belirtilmemiştir.

JavaScript motoru buna karar verir. Bellek temizliğini hemen gerçekleştirmeyi veya sonradan daha fazla silme işlemi yapılana kadar beklemeyi seçebilir. Bu nedenle, teknik olarak WeakMap’in geçerli eleman sayısı bilinmemektedir. Motor onu temizlemiş veya temizlememiş, veya bunu kısmen yapmış olabilir. Bu nedenle, WeakMap’e bir bütün olarak erişen metodlar desteklenmez.

Şimdi böyle bir şeye nerede ihtiyacımız var?

WeakMap fikri, var olan bir nesne için sadece var olduğu sürece bir şeyler depolayabilmemizdir. Ancak, nesneyi, onun için bir şey depoladığımız gerçeğiyle yaşamaya zorlamıyoruz.

weakMap.put(john, "gizli belgeler");
// eğer john ölürse, gizli belgeler yok olacak.

Objeler için bir yerde ana depolama alanına sahip olduğumuz ve sadece obje var olduğu sürece amacımıza yönelik ek bilgileri tutmamız gerektiği durumlarda kullanışlıdır.

Bir örnek görelim.

Örneğin, her kullanıcı için ziyaret sayısını tutan bir kodumuz var. Bilgiler bir map’te saklanır: kullanıcı anahtardır ve ziyaret sayısı değerdir. Bir kullanıcı ayrıldığında, ziyaret sayısını artık saklamak istemiyoruz.

Bunun bir yolu, terk eden kullanıcıları takip etmek ve depolamayı manuel olarak temizlemek olabilir:

let eda = { name: "Eda" };

// map: kullanıcı => ziyaret sayısı
let ziyaretSayisiMap = new Map();

// eda map için anahtardır
ziyaretSayisiMap.set(eda, 123);

// eğer eda bizi terk ederse, ona artık ihtiyacımız yoktur. (Gerçek hayatın aksine...)
eda = null;

// Ama o hala map'te kalmaya devam eder, onu temizlememiz lazım! (Peki ya kalbimizden?)
alert( ziyaretSayisiMap.size ); // 1
// Ayrıca hafızada da durur, çünkü Map onu anahtar olarak kullanıyor.

Bir diÄŸer yol WeakMap kullanmak olabilir:

let eda = { name: "Eda" };

let ziyaretSayisiMap = new WeakMap();

ziyaretSayisiMap.set(eda, 123);

// eğer eda bizi terk ederse, ona artık ihtiyacımız yoktur.
eda = null;

// WeakMap dışında bir referans yoktur,
// Bu yüzden obje hafıza ve ziyaretSayisiMap'ten otomatik olarak silinir.

Sıradan Map ile, bir kullanıcı ayrıldıktan sonra temizlik yapmak sıkıcı bir iÅŸ haline gelir: kullanıcıyı yalnızca ana depolama alanından (deÄŸiÅŸken veya dizi olsun) kaldırmamız deÄŸil, aynı zamanda ziyaretSayisiMap gibi ek alanları da temizlememiz gerekir. Ayrıca, kullanıcıların kodun bir yerinde yönetildiÄŸi ve ek yapının baÅŸka bir yerde olduÄŸu ve kaldırma iÅŸlemleri hakkında bilgi almadığı daha karmaşık durumlarda hantal olabilir.

WeakMap iÅŸleri daha basit hale getirebilir, çünkü otomatik olarak temizlenir. Yukarıdaki örnekte ziyaret sayısı gibi bilgiler, yalnızca anahtar nesne var olduÄŸunda yaÅŸar.

WeakSet benzer ÅŸekilde davranır:

• Sete benzer, ancak WeakSete yalnızca nesneler ekleyebiliriz (ilkel deÄŸil).
• Bir nesne ona baÅŸka bir yerden ulaşılabildiÄŸi sürece set içinde var olur.
• Set gibi, add, has ve deleteyi destekler, ama size, keys() ve yinelemeleri desteklemez.

Örneğin, bir ögenin kontrol edilip edilmediğini takip etmek için kullanabiliriz:

let messages = [
    {mesaj: "Merhaba", kimden: "John"},
    {mesaj: "Nasıl gidiyor?", kimden: "John"},
    {mesaj: "Görüşürüz", kimden: "Alice"}
];

// dizi elemanları ile doldur (3 eleman)
let unreadSet = new WeakSet(messages);

// unreadSet'i mesajın okunup okunmadığını görmek için kullanabiliriz
alert(unreadSet.has(messages[1])); // true
// okuduktan sonra sil
unreadSet.delete(messages[1]); // true

// mesaj geçmişini kaydırdığımızda set otomatik olarak temizlenir
messages.shift();
// unreadSet'i temizlememize gerek yok, şu an 2 elemanı var
// ne yazık ki, ögelerin tam sayısını elde etmek için bir yöntem yoktur, bu yüzden gösteremezsiniz

WeakMap ve WeakSetin en dikkate deÄŸer sınırlaması, yinelemelerin olmaması ve mevcut tüm içeriÄŸin alınamamasıdır. Bu rahatsız edici görünebilir, ancak aslında WeakMap / WeakSetin ana iÅŸlerini yapmasını engellemez – baÅŸka bir yerde saklanan / yönetilen nesneler için “ek” veri depolama alanı olur.

Özet

• Map – anahtarlı deÄŸerler tutan bir yapıdır.(collection)

  normal Objeden farkları:

  • Herhangi bir anahtar için objeler anahtar olabilir.
  • Yinelemeler eklenme sırasıyla yapılır.
  • Ek olarak kullanışlı metodlar, size özelliÄŸi.

• Set – eÅŸsiz deÄŸerler tutan bir yapı.(collection)

  • Bir dizi aksine elemanların tekrar sıralanmasına izin vermez.
  • Eklenme sırasıyla tutar.

• WeakMap – anahtar olarak sadece obje alan ve baÅŸka yolla ulaşılamaz hale geldiklerinde onları silen Mapin farklı bir biçimi.

  • Bir bütün olarak yapı üzerinde yapılan iÅŸlemleri desteklemez: size yok, clear() yok, yineleme yok.

• WeakSet – sadece obje tutan ve baÅŸka yolla ulaşılamaz hale geldiklerinde onları silen Setin farklı bir biçimi.

  • Aynı ÅŸekilde size/clear() ve yinelemeleri desteklemez.

WeakMap ve WeakSet, “ana” nesne depolama alanına ek olarak “ikincil” veri yapıları olarak kullanılır. Nesne, ana depolama alanından kaldırıldığında, yalnızca WeakMap / WeakSet içinde kalır, otomatik olarak temizlenir.