DoÄŸal prototipler

"prototype" özelliÄŸi JavaScript çekirdeÄŸinde oldukça fazla kullanılmaktadır. Tüm varsayılan yapıcı fonksiyonlar bunu kullanır.

Önce basit objeler, sonra daha karmaşık olanları için nasıl çalıştığını göreceğiz.

Object.prototype

Diyelim ki boş bir objeyi yazdırdınız:

let obj = {};
alert( obj ); // "[object Object]" ?

"[object Object]" yazısını oluÅŸturan kod nerede? Bu varsayılan toString metodu, ama asıl soru nerede? bu obj boÅŸ!

…Fakat obj = {} ile obj = new Object() aslında aynı anlama gelmektedir. Object object yapıcı fonksiyonudur. Bu fonksiyon Object.prototype’e ki bu da büyük bir toString’e sahip objeye ve diÄŸer fonksiyonlara sahiptir.

Aşağıdaki gibi( Tamamı gömülüdür):

new Object() çaÄŸrıldığında ( veya {...} ile yaratıldığında ) Objenin [[Prototype]]'i bir önceki bölümde bahsettiÄŸimiz gibi Object.prototype’a ayarlanır.

Sonrasında obj.toString() çaprıldığında – Bu metod Object.prototype’tan alınır.

Bunu ÅŸu ÅŸekilde kontrol edebiliriz:

let obj = {};

alert(obj.__proto__ === Object.prototype); // true
// obj.toString === obj.__proto__.toString == Object.prototype.toString

Object.prototype’ın üstünde baÅŸka bir [[Prototype]] yoktur.

alert(Object.prototype.__proto__); // null

Diğer gömülü prototipler

Array, Date, Function gibi diÄŸer gömülü objeler metodlarını prototype üzerinde tutar.

ÖrneÄŸin, [1,2,3] bir array yarattığınızda içte varsayılan new Array() yapıcısı kullanılır. Bundan dolayı dizi dizi objesi yeni bir objeye yazılır ve Array.prototype bunun prototipi olur ve metodlar saÄŸlar. Bu hafızayı oldukça etkin kullanmaya yarar.

Tanım gereÄŸi, tüm gömülü prototipler üstünde Object.prototype’a sahip olmalıdır. Bazen “her ÅŸey objelerden kalıtım alır” sözünü duyarsınız.

Aşağıda bunun etraflı bir görselini görebilirsiniz.

Prototipleri inceleyecek olursak:

let arr = [1, 2, 3];

// Array.prototype'tan mı kalıtım alıyor?
alert( arr.__proto__ === Array.prototype ); // true

// peki ya Object.prototype'tan mı?
alert( arr.__proto__.__proto__ === Object.prototype ); // true

// Peki ya onun üzerine bir null.
alert( arr.__proto__.__proto__.__proto__ ); // null

Bazı metodlar üst üste gelebilir, örneÄŸin Array.prototype kendine ait bir toString metoduna sahiptir ve bu da elemanları arasına virgül koyarak çıktı vermesini saÄŸlar:

let arr = [1, 2, 3]
alert(arr); // 1,2,3 <--  Array.prototype.toString'in sonucu

Daha önce de gördüğümüz gibi, Object.prototype’ın toString metodu bulunmaktadır fakat Array.prototype bu zincirlemede daha yakındır ve bundan dolayı diziler bunu kullanır.

Chrome Developer Tools konsolunda da bu kalıtımı ( console.dir kullanarak görebilirsiniz )

DiÄŸer gömülü objeler de aynı ÅŸekilde çalışır, hatta fonksiyonlar bile. Bunlar gömülü Fonksiyon yapıcısının objeleridir, call/apply gibi metodları ve diÄŸerleri Function.prototype’tan alınmıştır. Fonksiyonların kendine ait toString metdoları da bulunmaktadır.

function f() {}

alert(f.__proto__ == Function.prototype); // true
alert(f.__proto__.__proto__ == Object.prototype); // true, objelerden kalıtım alır.

Ä°lkel tipler

En karışık yapılar karakter dizileri, sayılar ve boolean ile yapılır.

Hatırlayacağınız üzere bunlar obje deÄŸildirler. Fakat özelliklerine eriÅŸmeye çalıştığınızda, gömülü yapıcı obje ile geçici objeler üretilir. Bunlar String, Number, Boolean metodlarını saÄŸlar ve yok olurlar.

Bu objeler gizli üretilir ve çoÄŸu motor bunları optimize edebilir, Fakat ÅŸartname bunu tam olarak bu ÅŸekilde tanımlar. Bu objelerin metodları da prototype’ta yer alır, String.prototype, Number.prototype ve Boolean.prototype olarak bulunur.

String.prototype.show = function() {
  alert(this);
};

"BOOM!".show(); // BOOM!

Geliştirme sürecinde hangi fikirlerin gömülü olması gerektiğine dair fikrimiz olabilir. Hatta doğal prototiplere ekleme yapmak için istek duyabilirsiniz. Fakat bu genelde kötü bir fikiridir.

Prototipler evrenseldir, bundan dolayı kolayca ikilik çıkarabilir. EÄŸer iki kütüphane String.prototype.show ÅŸeklinde metod eklerse bunlardan biri diÄŸerinin üzerine yazar.

Modern programlama da sadece bir koşulda doğal prototiplerin düzenlenmesine izin verilir. Buna pollyfills denir. Diğer bir deyişle eğer JavaScript şartnamesinde bir metod var fakat bu JavaScript motoru tarafından henüz desteklenmiyorsa, bunu elle yazmak ve gömülü prototipe eklemek mümkündür.

Örneğin:

if (!String.prototype.repeat) { // Eğer böyle bir metod yoksa
  // prototip'e ekle

  String.prototype.repeat = function(n) {
    // karakteri n defa tekrarlar

    // aslında kod bundan daha karmaşık olmalıdır.
    // eğer n negatif bir sayı gelirse hata dönder
    // Algoritma ÅŸartnamede belirlenmiÅŸtir.
    return new Array(n + 1).join(this);
  };
}

alert( "La".repeat(3) ); // LaLaLa

Prototiplerden ödünç alma

Dekoratörler ve iletilme, call/apply bölümünde metod ödünç almadan bahsetmiştik.

function showArgs() {
  // Array'den join i ödünç al ve argüman kaynağında çağır.
  alert( [].join.call(arguments, " - ") );
}

showArgs("John", "Pete", "Alice"); // John - Pete - Alice

join Array.prototype içerisinde bulunduÄŸundan dolayı, oradan doÄŸrudan çağırabilir ve ÅŸu ÅŸekilde tekrar yazabiliriz:

function showArgs() {
  alert( Array.prototype.join.call(arguments, " - ") );
}

Bu daha etkin çünkü ayrıca bir dizi [] objesi yaratmaktan kaçınılmıştır. Fakat biraz uzun sürmüştür.

Özet

• Tüm gömülü objeler aynı yapıyı paylaşır:
  • Metodlar prototiplerde saklanır ( Array.prototype, Object.prototype, Date.prototype vs. )
  • Veriyi objenin kendisi tutar ( dizi elemanları, obje özellikleri, tarih vs. )
• Ä°lkel veriler de saklayıcı objelerin prototiplerinde metodlarını tutarlar:Number.prototype, String.prototype, Boolean.prototype. Sadece undefined ve null için saklayıcı objeler bulunmamaktadır.
• Gömülü prototipler yeni metodlar ile deÄŸiÅŸtirilebilir. Fakat bunların deÄŸiÅŸtirilmesi önerilmez. Tek deÄŸiÅŸtirilebilir diyeceÄŸimiz olay yeni bir standart’ın eklenmesi olabilir, JavaScript motoru henüz o özelliÄŸi uygulamamışsa bu standart’ı siz uygulayabilirsiniz.