Proxy ve Reflect

Bir proxy (vekil), başka bir nesneyi sarmalar ve özellik okuma/yazma gibi işlemleri engeller (intercept eder). Bu işlemleri kendisi yönetebilir veya şeffaf bir şekilde hedef nesnenin yönetmesine izin verebilir.

Proxy’ler birçok kütüphanede ve bazı tarayıcı framework’lerinde kullanılır. Bu bölümde birçok pratik kullanım örneği göreceğiz.

Sözdizimi:

let proxy = new Proxy(target, handler)

• target – sarmalanacak nesne; fonksiyonlar da dahil olmak üzere herhangi bir ÅŸey olabilir.
• handler – iÅŸlemleri yakalayan (“trap” adı verilen) metotları içeren bir nesnedir. ÖrneÄŸin, bir özelliÄŸi okumak için get, bir özelliÄŸe yazmak için set gibi.

proxy üzerinde bir iÅŸlem yapılırsa, handler içinde o iÅŸleme karşılık gelen bir trap varsa, o çalıştırılır; yoksa iÅŸlem targetüzerinde gerçekleÅŸtirilir.

Basit bir örnek olarak, hiç trap içermeyen bir proxy oluşturalım:

let target = {};
let proxy = new Proxy(target, {}); // boÅŸ handler

proxy.test = 5; // proxy’ye yazma (1)
alert(target.test); // 5, özellik target üzerinde belirdi!

alert(proxy.test); // 5, proxy’den de okuyabiliyoruz (2)

for(let key in proxy) alert(key); // test, döngü çalışıyor (3)

Hiç trap olmadığından, proxy üzerindeki tüm iÅŸlemler target’a yönlendirilir.

1. proxy.test= yazma iÅŸlemi, deÄŸeri target üzerine yazar.
2. proxy.test okuma iÅŸlemi, deÄŸeri target’tan döndürür.
3. proxy üzerinde döngü yapmak, target’taki deÄŸerleri döndürür.

Gördüğümüz gibi, trap olmadan proxy, target üzerinde ÅŸeffaf bir sarmalayıcı gibi davranır.

Proxy, özel bir “egzotik nesnedir”. Kendi özellikleri yoktur. BoÅŸ bir handler ile, iÅŸlemleri tamamen target’a yönlendirir.

Eğer sihirli bir davranış istiyorsak, trap’ler eklememiz gerekir.

Proxy spesifikasyonu’nda tanımlanmış bir dizi dahili nesne işlemi vardır. Bir proxy, bunlardan herhangi birini yakalayabilir; bunun için handler’a karşılık gelen metodu eklememiz yeterlidir.

Aşağıdaki tabloda:

• İçsel Metot(Internal Method) Spesifikasyondaki dahili iÅŸlemin adıdır. ÖrneÄŸin, [[Get]] bir özelliÄŸi okuma iÅŸlemidir.
• Handler Metodu(Handler Method) handler’a eklememiz gereken metot adıdır; bu metot iÅŸlemi yakalar ve özel bir davranış tanımlar.

Haydi bunun pratik örneklerde nasıl çalıştığına bakalım.

“get” tuzağı ile varsayılan değer

En yaygın trap’ler özellik okuma/yazma içindir.

Okumayı yakalamak için, handler içinde get(target, property, receiver) adlı bir metot bulunmalıdır.

Bir özellik okunduğunda tetiklenir:

• target – hedef nesnedir; new Proxy’ye ilk argüman olarak verilen nesne,
• property – özellik adı,
• receiver – eÄŸer özellik bir getter ise, o kodda this olarak kullanılacak nesnedir. Genellikle bu proxy nesnesinin kendisidir (veya proxy’den miras alıyorsak ondan türeyen nesne).

Bir nesne için varsayılan deÄŸerleri uygulamak üzere get’i kullanalım.

ÖrneÄŸin, sayısal bir dizinin var olmayan indeksler için undefined yerine 0 döndürmesini istiyoruz.

Bunu, okumayı yakalayan ve öyle bir özellik yoksa varsayılan değer döndüren bir proxy ile saralım:

let numbers = [0, 1, 2];

numbers = new Proxy(numbers, {
  get(target, prop) {
    if (prop in target) {
      return target[prop];
    } else {
      return 0; // varsayılan değer
    }
  }
});

alert( numbers[1] ); // 1
alert( numbers[123] ); // 0 (böyle bir değer yok)

Bu yaklaşım geneldir. “Varsayılan” deÄŸer mantığını Proxy ile istediÄŸimiz gibi kurabiliriz.

Diyelim ki elimizde ifadeler ve onların çevirilerinden oluşan bir sözlük var:

let dictionary = {
  'Hello': 'Hola',
  'Bye': 'Adiós'
};

alert( dictionary['Hello'] ); // Hola
alert( dictionary['Welcome'] ); // undefined

Åžu anda, bir ifade yoksa dictionary’den okumak undefined döndürüyor. Ama pratikte, çevrilmemiÅŸ bir ifadeyi olduÄŸu gibi bırakmak çoÄŸu zaman undefined’dan daha iyidir. O hâlde, undefined yerine varsayılan deÄŸerin çevrilmemiÅŸ ifadenin kendisi olmasını saÄŸlayalım.

Bunu baÅŸarmak için, okumayı yakalayan bir proxy iledictionary’yi saracağız:

let dictionary = {
  'Hello': 'Hola',
  'Bye': 'Adiós'
};

dictionary = new Proxy(dictionary, {
  get(target, phrase) { // dictionary’den bir özellik okunmasını yakala
    if (phrase in target) { // sözlükte varsa
      return target[phrase]; // çeviriyi döndür
    } else {
      // yoksa, çevrilmemiş ifadeyi döndür
      return phrase;
    }
  }
});

// Sözlükte rastgele ifadeleri ara!
// En kötü ihtimalle çevrilmemiş olarak dönerler.
alert( dictionary['Hello'] ); // Hola
alert( dictionary['Welcome to Proxy']); // Welcome to Proxy (çeviri yok)

dictionary = new Proxy(dictionary, ...);
numbers = new Proxy(numbers, ...);

“set” tuzağı ile doğrulama (Validation)

Şimdi yazma işlemlerini de yakalayalım.

Diyelim ki yalnızca sayılardan oluşan bir dizi istiyoruz. Eğer farklı türde bir değer eklenirse, bir hata fırlatılmalı.

set tuzağı (trap), bir özellik yazıldığında tetiklenir: set(target, property, value, receiver)

• target – hedef nesnedir; new Proxy’ye ilk argüman olarak verilen nesne,
• property – özellik adı,
• value – özellik deÄŸeri,
• receiver – get tuzağındakiyle aynıdır; yalnızca özellik bir setter ise önemlidir.

set tuzağı, iÅŸlem baÅŸarılıysa true, baÅŸarısızsa false döndürmelidir (aksi hâlde TypeError oluÅŸur).

Yeni değerleri doğrulamak için bunu kullanalım:

let numbers = [];

numbers = new Proxy(numbers, { // (*)
  set(target, prop, val) { // özelliğe yazmayı yakala
    if (typeof val == 'number') {
      target[prop] = val;
      return true;
    } else {
      return false;
    }
  }
});

numbers.push(1);
numbers.push(2);
alert("Length is: " + numbers.length); // 2

numbers.push("test"); // TypeError ('set' on proxy returned false)

alert("Bu satıra asla ulaşılmaz (yukarıdaki satırda hata var)");

Dikkat ederseniz, dizinin yerleÅŸik iÅŸlevleri hâlâ çalışıyor! Yeni deÄŸerler eklendiÄŸinde length özelliÄŸi otomatik olarak artıyor. Proxy’miz hiçbir ÅŸeyi bozmadı.

Ayrıcapush, unshift gibi deÄŸer ekleyen metotları da yeniden tanımlamamız gerekmedi. Çünkü bunlar dahili olarak [[Set]] iÅŸlemini kullanırlar ve bu iÅŸlem proxy tarafından yakalanır.

Kod bu sayede hem temiz hem de kısa olur.

“deleteProperty” ve “ownKeys” ile korunan özellikler

Yaygın bir konvansiyona göre, _ (alt çizgi) ile baÅŸlayan özellikler ve metotlar içseldir.
Bu tür özelliklere nesnenin dışından erişilmemelidir.

Teknik olarak erişmek mümkündür:

let user = {
  name: "John",
  _password: "secret"
};

alert(user._password); // secret

Åžimdi _ ile baÅŸlayan özelliklere eriÅŸimi engellemek için proxy kullanalım.

Bunun için şu tuzaklara ihtiyacımız var:

• get okuma sırasında hata fırlatmak için,
• set yazma sırasında hata fırlatmak için,
• deleteProperty silme sırasında hata fırlatmak için,
• ownKeys _ ile baÅŸlayan özellikleri for...in döngüsü veya Object.keys() gibi iÅŸlemlerden gizlemek için.

Kod ÅŸu ÅŸekilde olur:

let user = {
  name: "John",
  _password: "***"
};

user = new Proxy(user, {
  get(target, prop) {
    if (prop.startsWith('_')) {
      throw new Error("EriÅŸim reddedildi");
    }
    let value = target[prop];
    return (typeof value === 'function') ? value.bind(target) : value; // (*)
  },
  set(target, prop, val) { // yazma iÅŸlemini yakala
    if (prop.startsWith('_')) {
      throw new Error("EriÅŸim reddedildi");
    } else {
      target[prop] = val;
    }
  },
  deleteProperty(target, prop) { // silme iÅŸlemini yakala
    if (prop.startsWith('_')) {
      throw new Error("EriÅŸim reddedildi");
    } else {
      delete target[prop];
      return true;
    }
  },
  ownKeys(target) { // özellik listesini yakala
    return Object.keys(target).filter(key => !key.startsWith('_'));
  }
});

// "get" -> _password okunamaz
try {
  alert(user._password); // Hata: EriÅŸim reddedildi
} catch(e) { alert(e.message); }

// "set" -> _password yazılamaz
try {
  user._password = "test"; // Hata: EriÅŸim reddedildi
} catch(e) { alert(e.message); }

// "deleteProperty" -> _password silinemez
try {
  delete user._password; // Hata: EriÅŸim reddedildi
} catch(e) { alert(e.message); }

// "ownKeys" -> _password filtrelenir
for(let key in user) alert(key); // name

Lütfen get tuzağındaki, (*) satırındaki önemli detaya dikkat edin:

get(target, prop) {
  // ...
  let value = target[prop];
  return (typeof value === 'function') ? value.bind(target) : value; // (*)
}

Bir nesne metodu çaÄŸrıldığında, örneÄŸin user.checkPassword(), bu metodun _password’a eriÅŸebilmesi gerekir:

user = {
  // ...
  checkPassword(value) {
    // nesne metodu _password'ı okuyabilmeli
    return value === this._password;
  }
}

Normalde, user.checkPassword() çaÄŸrısında this olarak proxylanmış user geçer (noktadan önceki nesne this olur). Bu yüzden metod this._password’a eriÅŸmeye çalıştığında, özellik koruması devreye girer ve hata fırlatır. Ä°ÅŸte bu nedenle (*) satırında metodu target’a baÄŸlarız (bind). Böylece o fonksiyon içindeki tüm iÅŸlemler doÄŸrudan orijinal nesneye yapılır ve özellik korumasına takılmaz.

Bu çözüm ideal değildir; çünkü metot, proxylanmamış nesneyi başka bir yere aktarabilir ve sonrasında işler karışabilir: Orijinal nesne nerede, proxy nerede?

Bir nesne birden fazla kez proxylanabilir (farklı proxy’ler nesneye farklı “ince ayarlar” ekleyebilir), bu da garip hatalara yol açabilir.

Dolayısıyla, metotları olan karmaşık nesneler için bu tür bir proxy kullanımı önerilmez.

“has” tuzağı ile “in range” (aralıkta mı?) denetimi

Bir aralık (range) nesnemiz olduğunu varsayalım:

let range = {
  start: 1,
  end: 10
};

Bir sayının range içinde olup olmadığını denetlemek için “in” operatörünü kullanmak istiyoruz.

“has” tuzağı, “in” çaÄŸrılarını yakalar: has(target, property)

• target – new Proxy’ye ilk argüman olarak geçirilen hedef nesne,
• property – özellik adı

Örnek:

let range = {
  start: 1,
  end: 10
};

range = new Proxy(range, {
  has(target, prop) {
    return prop >= target.start && prop <= target.end
  }
});

alert(5 in range); // true
alert(50 in range); // false

Güzel bir sözdizim şekeri, değil mi?

Fonksiyonları sarmalamak: “apply”

Bir fonksiyonun etrafına da proxy sarabiliriz.

apply(target, thisArg, args) tuzağı, proxy’nin fonksiyon gibi çaÄŸrılmasını yakalar:

• target hedef nesne (fonksiyon),
• thisArg çaÄŸrıda kullanılacak this deÄŸeri,
• args argümanların listesi.

ÖrneÄŸin, Dekoratörler ve iletilme, call/apply bölümünde yaptığımız delay(f, ms) dekoratörünü hatırlayalım.

Orada proxy kullanmadan yapmıştık. delay(f, ms) çaÄŸrısı, tüm çaÄŸrıları ms milisaniye sonra f’e ileten bir fonksiyon döndürüyordu.

Fonksiyon-tabanlı uygulama:

// proxy yok, sadece bir sarmalayıcı fonksiyon
function delay(f, ms) {
  // timeout sonrası çağrıyı f'ye ileten bir sarmalayıcı döndür
  return function() { // (*)
    setTimeout(() => f.apply(this, arguments), ms);
  };
}

function sayHi(user) {
  alert(`Hello, ${user}!`);
}

// artık sayHi çağrıları 3 saniye gecikmeli
sayHi = delay(sayHi, 3000);

sayHi("John"); // Hello, John! (3 saniye sonra)

Gördüğünüz gibi, çoÄŸunlukla çalışıyor. (*) satırındaki sarmalayıcı fonksiyon, çaÄŸrıyı bekleme süresinden sonra gerçekleÅŸtiriyor.

Ama sarmalayıcı fonksiyon, özellik okuma/yazma gibi diğer işlemleri iletmez. Dolayısıyla, orijinal fonksiyonun bir özelliği varsa, sarmalamadan sonra ona erişemeyiz:

function delay(f, ms) {
  return function() {
    setTimeout(() => f.apply(this, arguments), ms);
  };
}

function sayHi(user) {
  alert(`Hello, ${user}!`);
}

alert(sayHi.length); // 1 (function length argüman sayısıdır)

sayHi = delay(sayHi, 3000);

alert(sayHi.length); // 0 (sarmalayıcının argümanı yok)

Proxy çok daha güçlüdür; çünkü her ÅŸeyi hedef nesneye iletir.

Sarmalayıcı fonksiyon yerine Proxy kullanalım:

function delay(f, ms) {
  return new Proxy(f, {
    apply(target, thisArg, args) {
      setTimeout(() => target.apply(thisArg, args), ms);
    }
  });
}

function sayHi(user) {
  alert(`Hello, ${user}!`);
}

sayHi = delay(sayHi, 3000);

alert(sayHi.length); // 1 (*) proxy "length" okuma iÅŸlemini hedefe iletir

sayHi("John"); // Hello, John! (3 saniye sonra)

Sonuç aynı, ancak artık yalnızca çaÄŸrılar deÄŸil, proxy üzerindeki tüm iÅŸlemler de orijinal fonksiyona iletiliyor. Bu nedenle (*) satırında sarmalamadan sonra sayHi.length doÄŸru ÅŸekilde döndü.

Böylece daha “zengin” bir sarmalayıcı elde etmiş olduk.

Başka trap’ler de var, fakat sanırım artık mantığı anladınız.

Reflect

Reflect API’si, Proxy ile birlikte çalışmak üzere tasarlanmıştır.

Yakalanabilecek (trap’lenebilecek) her dahili nesne iÅŸlemi için bir Reflect metodu vardır.
Bu metodun adı ve parametreleri, ilgili trap ile aynıdır ve işlemi hedef nesneye iletmek için kullanılabilir.

Örneğin:

let user = {
  name: "John",
};

user = new Proxy(user, {
  get(target, prop, receiver) {
    alert(`GET ${prop}`);
    return Reflect.get(target, prop, receiver); // (1)
  },
  set(target, prop, val, receiver) {
    alert(`SET ${prop} TO ${val}`);
    return Reflect.set(target, prop, val, receiver); // (2)
  }
});

let name = user.name; // GET name
user.name = "Pete"; // SET name TO Pete

• Reflect.get, tıpkı target[prop] gibi özelliÄŸi okur.
• Reflect.set, tıpkı target[prop] = value gibi özelliÄŸi yazar, ayrıca doÄŸru dönüş deÄŸerini de garanti eder.

ÇoÄŸu durumda Reflect kullanmadan da aynı iÅŸi yapabiliriz, ancak bazı ince detayları kaçırabiliriz.

AÅŸağıdaki örneÄŸe bakalım; Reflect kullanılmamış ve yanlış sonuç veriyor:

Bir user nesnesini proxy’liyoruz, sonra ondan kalıtım alıp bir getter kullanıyoruz:

let user = {
  _name: "Guest",
  get name() {
    return this._name;
  }
};

user = new Proxy(user, {
  get(target, prop, receiver) {
    return target[prop]; // (*)
  }
});


let admin = {
  __proto__: user,
  _name: "Admin"
};

// Beklenen: Admin
alert(admin.name); // Guest (?!?)

Gördüğünüz gibi sonuç hatalı! admin.name deÄŸerinin "Admin" olması gerekirken "Guest" döndü. Proxy olmadan "Admin" olacaktı; proxyleme nesneyi “bozmuş” gibi görünüyor.

Peki neden? Son satırdaki çağrının ne yaptığına bakalım:

1. admin içinde name özelliÄŸi yok, bu yüzden çaÄŸrı admin’in prototipine gider.
2. Prototip bir proxy olduÄŸu için, get tuzağı name okuma giriÅŸimini yakalar.
3. (*) satırında target[prop] döndürülür, peki target nedir?
   • target, get’in ilk parametresidir ve her zaman new Proxy’ye verilen orijinal nesnedir(user).
   • Dolayısıyla, target[prop] getter name’i this=target=user olarak çağırır.
   • Bu yüzden sonuç "Guest" olur.

Bunu nasıl düzeltiriz? Ä°ÅŸte bu noktada üçüncü parametre olan receiver devreye girer! receiver, doÄŸru this deÄŸerini tutar. Sadece Reflect.get’i çağırarak bu deÄŸeri aktarabiliriz.

Doğru çözüm şöyle olur:

let user = {
  _name: "Guest",
  get name() {
    return this._name;
  }
};

user = new Proxy(user, {
  get(target, prop, receiver) {
    return Reflect.get(target, prop, receiver); // (*)
  }
});


let admin = {
  __proto__: user,
  _name: "Admin"
};

alert(admin.name); // Admin

Artık receiver, doÄŸru this deÄŸerini tutarak getter’a Reflect.get aracılığıyla ((*) satırında) aktarılır ve her ÅŸey düzgün çalışır.

Ayrıca tuzağı şu şekilde de yazabilirdik:

get(target, prop, receiver) {
  return Reflect.get(...arguments);
}

Reflect çaÄŸrıları, tuzaklarla birebir aynı isimlere ve argümanlara sahiptir. Bu özellikle böyle tasarlanmıştır.

Dolayısıyla return Reflect... ÅŸeklinde bir çaÄŸrı, iÅŸlemi güvenli bir ÅŸekilde iletmenin ve hiçbir detayı unutmamanın en kolay yoludur.

Proxy Sınırlamaları

Proxy’ler, var olan nesnelerin (hatta yerleşik olanların, örn. diziler) davranışlarını değiştirmek veya özelleştirmek için mükemmel bir araçtır.

Yine de, bazı sınırlamaları vardır.

Yerleşik Nesneler: İçsel Slotlar (Internal Slots)

Birçok yerleÅŸik nesne, örneÄŸin Map, Set, Date, Promise ve benzerleri, “içsel slot” (internal slot) denen yapıları kullanır.

Bunlar özelliklere benzer, ancak dahili amaçlar için ayrılmıştır. YerleÅŸik metotlar bu slotlara doÄŸrudan eriÅŸir, [[Get]]/[[Set]] gibi içsel metotları kullanmazlar. Bu yüzden Proxy bunları yakalayamaz.

“Eee ne olmuş, sonuçta dahili yapılar!” diyebilirsiniz.

Ama sorun şudur: Böyle bir yerleşik nesne proxylenirse, proxy bu içsel slotlara sahip olmaz ve dolayısıyla yerleşik metotlar çalışmaz.

Örneğin:

let map = new Map();

let proxy = new Proxy(map, {});

proxy.set('test', 1); // Hata

Bir Map üzerinde set çağırmak baÅŸarısız olur; çünkü bu davranış içsel implementasyona baÄŸlıdır.

Dahili olarak bir Map, tüm verilerini [[MapData]] adlı içsel slotta saklar. Proxy’de böyle bir slot yoktur. set metodu this.[[MapData]]’ya eriÅŸmeye çalışır; ancak this=proxy olduÄŸu için bulamaz ve hata verir.

Neyse ki bunu düzeltmenin bir yolu var:

let map = new Map();

let proxy = new Proxy(map, {
  get(target, prop, receiver) {
    let value = Reflect.get(...arguments);
    return typeof value == 'function' ? value.bind(target) : value;
  }
});

proxy.set('test', 1);
alert(proxy.get('test')); // 1 (çalışıyor!)

Åžimdi düzgün çalışıyor, çünkü get tuzağı fonksiyon özellikleri (map.set gibi), hedef nesneye (map) baÄŸlıyor.

Böylece proxy.set(...) içindeki this artık proxy deÄŸil, orijinal map olur. Dolayısıyla set metodu this.[[MapData]] slotuna eriÅŸmeye çalıştığında baÅŸarılı olur.

Özel Alanlar (Private Fields)

Benzer bir durum, sınıflardaki özel (private) alanlarda da görülür.

ÖrneÄŸin, getName() metodu özel #name alanına eriÅŸir, ancak proxy uygulandıktan sonra bozulur:

class User {
  #name = "Guest";

  getName() {
    return this.#name;
  }
}

let user = new User();

user = new Proxy(user, {});

alert(user.getName()); // Error

Bunun nedeni, özel alanların (private fields) dahili slotlar (internal slots) kullanılarak uygulanmasıdır. JavaScript, bunlara eriÅŸirken [[Get]] veya [[Set]] mekanizmalarını kullanmaz.

user.getName() çaÄŸrısında, this deÄŸeri proxylanmış kullanıcı nesnesidir ve bu nesnede özel alanların bulunduÄŸu slot yoktur.

Daha önceki örneklerde olduÄŸu gibi, metodu hedef nesneye baÄŸlayarak (bind) bu durumu düzeltebiliriz:

class User {
  #name = "Guest";

  getName() {
    return this.#name;
  }
}

let user = new User();

user = new Proxy(user, {
  get(target, prop, receiver) {
    let value = Reflect.get(...arguments);
    return typeof value == 'function' ? value.bind(target) : value;
  }
});

alert(user.getName()); // Guest

Ancak bu çözümün daha önce açıkladığımız bir dezavantajı var: Metot, orijinal nesneye doğrudan erişim kazanır ve onu başka bir yere aktarabilir. Bu da diğer proxy işlevselliklerini bozabilir.

Proxy != target

Proxy ve orijinal nesne farklı nesnelerdir. Bu oldukça doğaldır, değil mi?

Yani bir nesneyi bir yerde saklayıp daha sonra proxy’larsak, bazı şeyler bozulabilir:

let allUsers = new Set();

class User {
  constructor(name) {
    this.name = name;
    allUsers.add(this);
  }
}

let user = new User("John");

alert(allUsers.has(user)); // true

user = new Proxy(user, {});

alert(allUsers.has(user)); // false

Gördüğünüz gibi, proxylamadan sonra user, allUsers kümesinde bulunamıyor çünkü proxy farklı bir nesne.

Geri Alınabilir Proxy’ler (Revocable Proxies)

Revocable proxy, yani “geri alınabilir proxy”, devre dışı bırakılabilen bir proxy türüdür.

Diyelim ki bir kaynağımız var ve istediğimiz anda bu kaynağa erişimi kapatmak istiyoruz.

Bunu, herhangi bir trap eklemeden bir “revocable proxy” ile sarmalayabiliriz.
Bu proxy işlemleri hedef nesneye iletir, ancak ayrıca onu devre dışı bırakmak için özel bir fonksiyon sağlar.

Sözdizimi şöyledir:

let {proxy, revoke} = Proxy.revocable(target, handler)

Bu çağrı, iki özellik döndürür:

• proxy vekil nesne,
• revoke bu proxy’yi devre dışı bırakmak için kullanılan fonksiyon.

Örnek:

let object = {
  data: "Valuable data"
};

let {proxy, revoke} = Proxy.revocable(object, {});

// nesne yerine proxy’yi bir yere aktarabiliriz...
alert(proxy.data); // Valuable data

// kodun ilerleyen bir kısmında
revoke();

// proxy artık çalışmaz (devre dışı)
alert(proxy.data); // Hata

revoke() çaÄŸrısı, proxy’nin hedef nesneyle olan tüm dahili baÄŸlantılarını kaldırır. Böylece artık birbirleriyle iliÅŸkili deÄŸildirler. Bu noktadan sonra hedef nesne, çöp toplayıcı (garbage collector) tarafından silinebilir.

Ayrıca revoke fonksiyonunu bir WeakMap içinde saklayarak, proxy üzerinden kolayca bulabiliriz:

let revokes = new WeakMap();

let object = {
  data: "Valuable data"
};

let {proxy, revoke} = Proxy.revocable(object, {});

revokes.set(proxy, revoke);

// ...kodun ilerleyen kısmında...
revoke = revokes.get(proxy);
revoke();

alert(proxy.data); // Hata (revoked)

Bu yaklaşımın avantajı, revoke fonksiyonunu her yere taşımak zorunda olmamamızdır. Proxy üzerinden WeakMap aracılığıyla gerektiÄŸinde eriÅŸebiliriz.

Burada Map yerine WeakMap kullanmamızın nedeni, çöp toplamayı engellememesidir. EÄŸer bir proxy nesnesine artık eriÅŸilmiyorsa (örneÄŸin hiçbir deÄŸiÅŸken onu tutmuyorsa), WeakMap onun bellekten silinmesine izin verir. Çünkü artık revoke fonksiyonuna da ihtiyacımız yoktur.

Referanslar

• Spesifikasyon: Proxy.
• MDN: Proxy.

Özet

Proxy, bir nesnenin etrafını saran ve iÅŸlemleri o nesneye yönlendiren (ve istenirse bazılarını yakalayan) bir yapıdır.

Her tür nesneyi, sınıflar ve fonksiyonlar dahil, sarmalayabilir.

Sözdizimi:

let proxy = new Proxy(target, {
  /* tuzaklar */
});

…Bundan sonra target yerine her yerde proxy kullanılmalıdır. Bir proxy’nin kendi özellikleri veya metotları yoktur. Bir iÅŸlem, uygun bir trap tanımlanmışsa yakalanır; yoksa hedef nesneye (target) iletilir.

Yakalanabilecek işlemler şunlardır:

• Özellik okuma (get), yazma (set), silme (deleteProperty), hatta var olmayan bir özellik bile.
• Fonksiyon çaÄŸrıları: new ile (construct tuzağı), new olmadan (apply tuzağı).
• Daha birçok iÅŸlem (tam liste makalenin başında ve MDN dokümentasyonunda yer alır).

Bu sayede:

• “Sanal” (virtual) özellikler ve metotlar oluÅŸturabiliriz,
• Varsayılan deÄŸerler tanımlayabiliriz,
• Gözlemlenebilir (observable) nesneler oluÅŸturabiliriz,
• Fonksiyon dekoratörleri (decorators) yazabiliriz, ve çok daha fazlasını yapabiliriz.

Bir nesneyi farklı Proxy katmanlarıyla birden fazla kez sarmalayabiliriz. Her biri farklı bir iÅŸlevsellik ekleyebilir.

Reflect API’si Proxy’yi tamamlamak üzere tasarlanmıştır. Her Proxy tuzağı için aynı argümanları alan bir Reflect çaÄŸrısı bulunur. Bu çaÄŸrılar, iÅŸlemleri hedef nesneye güvenli bir ÅŸekilde iletmek için kullanılmalıdır.

Proxy’lerin bazı sınırlamaları vardır:

• YerleÅŸik nesneler, “içsel slot” (internal slot) adı verilen alanlara sahiptir; bunlara eriÅŸim proxy ile yakalanamaz. (Yukarıda çözüm örneÄŸi verilmiÅŸtir.)
• Aynı durum özel (private) sınıf alanları için de geçerlidir; bunlar da slot’lar aracılığıyla uygulanır. Bu nedenle proxylanmış metod çaÄŸrıları, bu alanlara eriÅŸebilmek için this deÄŸerinin hedef nesne olması gerekir.
• Nesne eÅŸitlik testi (===) yakalanamaz.
• Performans: Proxy üzerinden özellik eriÅŸimi genellikle birkaç kat daha yavaÅŸtır. Ancak pratikte bu fark yalnızca dar boÄŸaz oluÅŸturan nesnelerde hissedilir.