Protitipsel Kalıtım

Programlarken genelde bir şeyi alır ve bunu genişletmek isteriz.

ÖrneÄŸin, kullanici adında bir obje ve bunun özellikleri ve metodları olsun, bunu biraz düzenleyerek admin ve misafir gibi iki farklı obje oluÅŸturmak isteriz. Yani kullanici objesini doÄŸrudan kopyalamak veya metodlarını tekrardan uygulamak deÄŸil bunlar üzerinden yeni objeler yaratmak isteyebiliriz.

Prototip kalıtımı buna olanak sağlamaktadır.

[[Prototype]]

Javascript objeleri gizli bir özellik olan [[Prototype]] özelliÄŸine sahiptirler. Bu null olabilir veya baÅŸka objeye referans verebilir. Referans verilen obje “prototip” olarak adlandırılır.

[[Prototip]]'in “büyülü” bir anlamı bulunmaktadır. Objeden bir özellik okunmak istendiÄŸinde, ve bu obje bulunamadığında JavaScript bunu otomatik olarak prototip’ten alır. Programlamada buna prototip kalıtımı denir. Birçok dil özelliÄŸi ve programlama tekniÄŸi bunun üzerine kuruludur.

[[Prototpe]] gizli bir özelliktir, fakat bunu ayarlamanın birçok yolu vardır.

Bunlardan biri __proto__ kullanmaktır:

let animal = {
  eats: true
};
let rabbit = {
  jumps: true
};

rabbit.__proto__ = animal;

Aklınızda bulunsun __proto__ [[Prototype]] ile aynı deÄŸildir. Bunun için alıcı/ayarlayıcı ( getter/setter)'dır. Bunun hakkında ilerleyen bölümlerde daha fazla açıklama yapılacaktır fakat ÅŸimdilik __proto__ yeterlidir.

ÖrneÄŸin rabbit adında bir özelliÄŸe arasanız ve bu özellik yoksa, JavaScript bunu otomatik olarak animal’dan alır.

Örneğin:

let animal = {
  eats: true
};
let rabbit = {
  jumps: true
};

rabbit.__proto__ = animal; // (*)

// Artık her ikisini de rabbit'te bulabilirsiniz.
alert( rabbit.eats ); // true (**)
alert( rabbit.jumps ); // true

(*) satırında animal’ın rabbit in özleliÄŸi olması saÄŸlanır

Sonrasında alert rabbit.eats (**)'i okur. Bu rabbit’te olmadığından JavaScript [[Prototype]]'ı takip eder ve bunu animal’in içerinde bulur.

Böylece “animal” rabbit’in prototip’i veya “rabbit prototipsel olarak animal kalıtımını almıştır” diyebiliriz.

Diyelim ki animal’ın birçok özelliÄŸi ve metodu olsun, bunları otomatik olarak rabbit de kullanabilir. Bu çeÅŸit özelliklere kalıtılmış özellikler denir.

EÄŸer animal’da bir metodumuz varsa bu metod rabbit tarafından çağırılabilir olmaktadır.

let animal = {
  eats: true,
  walk() {
    alert("Animal walk");
  }
};

let rabbit = {
  jumps: true,
  __proto__: animal
};

// walk prototipten alınmıştır.
rabbit.walk(); // Animal walk

Metod prototipten otomatik olarak şu şekilde alınmıştır:

Prototip zinciri daha da uzun olabilir:

let animal = {
  eats: true,
  walk() {
    alert("Animal walk");
  }
};

let rabbit = {
  jumps: true,
  __proto__: animal
};

let longEar = {
  earLength: 10,
  __proto__: rabbit
}

// walk prorotip zincirinden alınmıştır.
longEar.walk(); // Animal walk
alert(longEar.jumps); // true (rabbit'ten gelmekte)

Aslında iki tane kısıtlama bulunmaktadır:

1. Referanslar kapalı devre olamaz. Böyle bir duurmda hata verir.
2. __proto__'nun deÄŸeri ya obje olur ya da null DiÄŸer türlüsü ( tüm ilkel veri tipleri ) görmezden gelinir.

Çok açık olsa da tekrar söylemekte yarar var. Bir obje sadece bir tane [[Prototype]]'a sahip olabilir. Bir objenin iki farklı objeden kalıtım alamaz.

Kuralların Okuması/Yazılması.

Prototip sadece özelliklerin okunması için kullanılır.

Veri özelliklerinin yazılma/silinme ( alıcı/ayarlayıcı değil) işi doğrudan obje üzerinden yapılır.

AÅŸağıdaki örnekte rabbit’e kendi walk metodu atanmıştır:

let animal = {
  eats: true,
  walk() {
    /* Bu metod rabbit tarafından kullanılmayacaktır. */
  }
};

let rabbit = {
  __proto__: animal
}

rabbit.walk = function() {
  alert("Rabbit! Bounce-bounce!");
};

rabbit.walk(); // Rabbit! Bounce-bounce!

Artık rabbit.walk() metodu doÄŸrudan kendi içerisinde bulur ve çalıştırır. Prototip kullanmaz:

Alıcı/Ayarlayıcı için ise eğer özellik okunursa bu doğrudan prototipte okunur ve uyarılır.

ÖrneÄŸin aÅŸağıdaki admin.fullName özelliÄŸine bakın:

let user = {
  name: "John",
  surname: "Smith",

  set fullName(value) {
    [this.name, this.surname] = value.split(" ");
  },

  get fullName() {
    return `${this.name} ${this.surname}`;
  }
};

let admin = {
  __proto__: user,
  isAdmin: true
};

alert(admin.fullName); // John Smith (*)

// Ayarlayıcılar uyarıldı!
admin.fullName = "Alice Cooper"; // (**)

(*) satırında admin.fullName özelliÄŸi user prototipinde alıcıya sahiptir. Bundan dolayı çağırılır. (**) satırında ise ayarlayıcıya sahip olduÄŸundan bu da çağırılır.

“this”'in değeri

Yukarıdaki örnekte aklınıza şöyle bir soru gelebilir. set fullName(value) içerisinde this’in deÄŸeri nedir? this.name ve this.surname yazılan yerlerde admin mi yoksa user mı kullanılır?

Cevap basittir: this prototip tarafından hiçbir ÅŸekilde etkilenmez.

Metodun bulunduÄŸu yerin önemi olmaksızın, metod çaÄŸrısında this her zaman noktadan önceki bölümdür.

Öyleyese aslında ayarlayıcı admin’i this olarak kullanır. user’ı deÄŸil.

Çok büyük bir objeye ve buna ait birçok metoda, kalıtıma sahip olabileceğimizden dolayı bu aslında çok önemli bir olaydır. Sonrasında büyük objenin değil kalıtılmış objelerin metodlarını çalıştırabilir ve bunların özelliklerini değiştirebiliriz.

ÖrneÄŸin burada animal aslında “metod deposu”'nu temsil etmektedir. rabbit ise bunu kullanır.

rabbit.sleep() çaÄŸrısı rabbit üzerinde this.isSleeping’i ayarlar:

// animal metodları
let animal = {
  walk() {
    if (!this.isSleeping) {
      alert(`I walk`);
    }
  },
  sleep() {
    this.isSleeping = true;
  }
};

let rabbit = {
  name: "White Rabbit",
  __proto__: animal
};

// rabbit.isSleeping'i modifiye eder.
rabbit.sleep();

alert(rabbit.isSleeping); // true
alert(animal.isSleeping); // undefined (prototipte böyle bir özellik bulunmamaktadır.)

Sonuç görseli:

EÄŸer bird, sname gibi animal’dan miras alan objelere sahip olsaydık bunlar da animal’in metodlarına eriÅŸebilirlerdi. Fakat her metoddaki this baÄŸlı bulunduÄŸu objeye göre çalışırdı. Yani noktadan önceki metoda göre, animal’e göre deÄŸil. Bundan dolayı ne zaman this’e veri yazılsa o objelerin içerisine yazılır.

Sonuç olarak metodlar paylaşılsa bile objelerin durumları paylaşılmaz.

Özet

• JavaScript’te tüm objelerin gizli [[Prototype]]'ı bulunmaktaıd. Bu özellik ya baÅŸka bir objedir veya null’dur.
• EriÅŸmek için obj.__proto__ kullanılabilir. (elbette diÄŸer yollar da mevcuttur, ilerde bunlara deÄŸineceÄŸiz.)
• [[Prototype]] tarafından temsil edilen objeye “prototip” denir.
• EÄŸer bir obj’nin özelliÄŸini okumak veya bir metodunu çağırmak istersek ve o metod yok ise JavaScript bunu prototipte bulmaya çalışır. Yazma/Silme operasyonları doÄŸrudan obje üzerinde çalıştırılır. Özellik ayarlayıcı olmadığı sürece prototip kullanılmaz.
• EÄŸer obj.method()'u çağırırsak ve method prototipten alınırsa this yine de obj’i temsil eder. Bundan dolayı metodlar her zaman o anki obje ile çalışırlar miras kalsalar bile.