Prototipal Kalıtım

Neden Bu Konu Önemli?

Java, C++ veya Python'dan geliyorsan, "class" ve "kalıtım" kavramlarına alışkınsındır. Bu dillerde sınıflar, nesnelerin şablonudur — bir sınıf tanımlar, ondan nesneler üretirsin. Ama JavaScript temelde farklı çalışır. JavaScript'te sınıflar yoktu (ES6'ya kadar) ve hâlâ gerçek sınıflar yok. ES6'daki class keyword'ü, aslında prototipal kalıtımın üzerine yerleştirilmiş bir "sözdizimsel şeker"dir.

Peki prototipal kalıtım ne demek? Bunu şöyle düşün: bir aile şirketi. Baba bir iş kurmuş, bazı beceriler edinmiş. Oğlu şirkete katıldığında, kendi becerileri olmayan konularda babasına soruyor. Baba da bilmiyorsa, dedeye soruluyor. Bu "yukarı doğru sormak" zinciri, JavaScript'teki prototype chain (prototip zinciri) ile birebir örtüşüyor.

Bu derste JavaScript'in kalıtım modelinin temellerini — prototype chain, __proto__, Object.create, constructor fonksiyonlar ve new keyword'ünün arka planını — öğreneceğiz. Bu bilgi olmadan ES6 class'larını gerçek anlamda anlayamazsın.

Her Nesnenin Bir Prototipi Var

JavaScript'te (neredeyse) her nesnenin bir prototipi vardır. Prototip, o nesnenin "üst nesne"sidir — bir özellik veya metot nesnede bulunamazsa, prototipinde aranır.

// Basit bir nesne oluştur
const kedi = {
  tur: "kedi",
  miyavla() {
    return "Miyav!";
  },
};

// kedi nesnesinin prototipi nedir?
console.log(Object.getPrototypeOf(kedi));
// Object.prototype — tüm nesnelerin en üst prototipi

// Bu yüzden her nesne toString(), hasOwnProperty() gibi
// metotlara sahiptir — bunlar Object.prototype'tan gelir
console.log(kedi.toString());         // "[object Object]"
console.log(kedi.hasOwnProperty("tur")); // true
// kedi'nin kendisinde toString yok — prototipinden bulunuyor

Prototype Chain (Prototip Zinciri)

Bir özellik arandığında JavaScript şu sırayla bakar:

1. Nesnenin kendisi → bulunursa döner
2. Nesnenin prototipi → bulunursa döner
3. Prototipinin prototipi → bulunursa döner
4. ... (zincir yukarı doğru devam eder)
5. Object.prototype → son durak
6. null → zincirin sonu, undefined döner

const hayvan = {
  canli: true,
  nefesAl() {
    return "Nefes alıyor...";
  },
};

const kedi = Object.create(hayvan); // hayvan'ı prototip olarak kullan
kedi.miyavla = function () {
  return "Miyav!";
};

const tekir = Object.create(kedi); // kedi'yi prototip olarak kullan
tekir.isim = "Pamuk";

// Prototype chain: tekir → kedi → hayvan → Object.prototype → null

console.log(tekir.isim);      // "Pamuk" — tekir'in kendisinde
console.log(tekir.miyavla()); // "Miyav!" — kedi'den geliyor
console.log(tekir.nefesAl()); // "Nefes alıyor..." — hayvan'dan geliyor
console.log(tekir.canli);     // true — hayvan'dan geliyor
console.log(tekir.toString()); // "[object Object]" — Object.prototype'tan
console.log(tekir.ucabilir);  // undefined — zincirde hiç bulunamadı

proto vs prototype

Bu iki terim sürekli karıştırılır. Farkı net anlayalım:

// __proto__ → HER nesnenin sahip olduğu, prototipine işaret eden referans
// prototype → Sadece FONKSİYONLARIN sahip olduğu bir özellik
//             (new ile oluşturulacak nesnelerin prototipi olacak nesne)

function Kisi(ad) {
  this.ad = ad;
}

Kisi.prototype.selamla = function () {
  return `Merhaba, ben ${this.ad}`;
};

const ahmet = new Kisi("Ahmet");

// ahmet.__proto__ === Kisi.prototype → TRUE
console.log(Object.getPrototypeOf(ahmet) === Kisi.prototype); // true

// Kisi.prototype.__proto__ === Object.prototype → TRUE
console.log(Object.getPrototypeOf(Kisi.prototype) === Object.prototype); // true

// Zincir: ahmet → Kisi.prototype → Object.prototype → null

⚠️ Dikkat: __proto__ özelliği standart dışıdır (legacy). Prototipe erişmek için Object.getPrototypeOf(), ayarlamak için Object.setPrototypeOf() veya Object.create() kullan.

Object.create — Prototip Belirleme

Object.create(proto) belirtilen prototipi kullanarak yeni bir nesne oluşturur. Bu, prototipal kalıtımın en saf halidir.

// Object.create ile kalıtım zinciri
const arac = {
  tur: "araç",
  calistir() {
    return `${this.marka} çalıştırıldı`;
  },
  durdur() {
    return `${this.marka} durduruldu`;
  },
};

// araba, arac'ı prototip olarak kullanır
const araba = Object.create(arac);
araba.tur = "araba";
araba.tekerlekSayisi = 4;
araba.kornaCal = function () {
  return "Düüüt!";
};

// bmw, araba'yı prototip olarak kullanır
const bmw = Object.create(araba);
bmw.marka = "BMW";
bmw.model = "320i";

console.log(bmw.calistir());      // "BMW çalıştırıldı" — arac'tan
console.log(bmw.kornaCal());      // "Düüüt!" — araba'dan
console.log(bmw.tekerlekSayisi);  // 4 — araba'dan
console.log(bmw.marka);           // "BMW" — bmw'nin kendisinde

Object.create ile Property Descriptors

// İkinci parametre ile özellik tanımlayıcıları
const kullanici = Object.create(
  // Prototip
  {
    selamla() {
      return `Merhaba, ${this.ad}`;
    },
  },
  // Özellik tanımlayıcıları
  {
    ad: {
      value: "Ahmet",
      writable: true,
      enumerable: true,
      configurable: true,
    },
    id: {
      value: 1,
      writable: false,        // Değiştirilemez
      enumerable: true,
      configurable: false,     // Silinemez, yeniden tanımlanamaz
    },
  }
);

console.log(kullanici.selamla()); // "Merhaba, Ahmet"
kullanici.ad = "Mehmet";           // ✅ Değiştirilebilir
// kullanici.id = 2;              // ❌ Strict mode'da TypeError

Object.create(null) — Saf Sözlük

// Prototipi olmayan nesne — güvenli sözlük
const sozluk = Object.create(null);
// Bu nesnenin prototipi NULL — Object.prototype bile yok
// toString, hasOwnProperty, constructor — hiçbiri yok

sozluk["toString"] = "bir değer";
// Normal nesnede toString metotla çakışırdı — burada sorun yok!

console.log(sozluk.toString);  // "bir değer" — metot değil, string!
// Normal nesnede: console.log({}.toString) → function toString()

// JSON parse sonuçları için güvenli:
// Kötü niyetli JSON'da "__proto__" key'i bile sorun çıkarmaz
sozluk["__proto__"] = "tehlikeli";
console.log(Object.getPrototypeOf(sozluk)); // null — hâlâ güvenli

Constructor Fonksiyonlar ve new Keyword'ü

ES6 class'larından önce, JavaScript'te "sınıf" oluşturmanın yolu constructor (yapıcı) fonksiyonlardı.

// Constructor fonksiyon — büyük harfle başlar (convention)
function Kullanici(ad, email) {
  // `new` ile çağrıldığında `this` yeni nesneyi gösterir
  this.ad = ad;
  this.email = email;
  this.olusturmaTarihi = new Date();
}

// Metotları prototype'a ekle — tüm instance'lar paylaşır
Kullanici.prototype.selamla = function () {
  return `Merhaba, ben ${this.ad}`;
};

Kullanici.prototype.bilgiGoster = function () {
  return `${this.ad} (${this.email})`;
};

// new keyword'ü ile nesne oluştur
const ahmet = new Kullanici("Ahmet", "ahmet@test.com");
const ayse = new Kullanici("Ayşe", "ayse@test.com");

console.log(ahmet.selamla());     // "Merhaba, ben Ahmet"
console.log(ayse.bilgiGoster());  // "Ayşe (ayse@test.com)"

// Her iki instance da aynı prototype'ı paylaşır
console.log(ahmet.selamla === ayse.selamla); // true — aynı fonksiyon!

`new` Keyword'ü Arkada Ne Yapıyor?

new Kullanici("Ahmet", "ahmet@test.com") çağrıldığında JavaScript arkada 4 adım yapar:

// `new` operatörünün simülasyonu
function yeniOlustur(Constructor, ...args) {
  // 1. Boş bir nesne oluştur
  const nesne = {};
  
  // 2. Nesnenin prototipini Constructor.prototype'a bağla
  Object.setPrototypeOf(nesne, Constructor.prototype);
  
  // 3. Constructor'ı bu nesne context'inde çalıştır
  const sonuc = Constructor.apply(nesne, args);
  
  // 4. Constructor nesne döndürürse onu, yoksa yeni nesneyi döndür
  return sonuc instanceof Object ? sonuc : nesne;
}

// Bu iki satır eşdeğer:
const a = new Kullanici("Ahmet", "ahmet@test.com");
const b = yeniOlustur(Kullanici, "Ahmet", "ahmet@test.com");

Neden Metotları prototype'a Ekliyoruz?

// ❌ YANLIŞ — metodu constructor içinde tanımlamak
function KullaniciBad(ad) {
  this.ad = ad;
  // Her instance için AYRI fonksiyon oluşturulur — bellek israfı!
  this.selamla = function () {
    return `Merhaba, ben ${this.ad}`;
  };
}

const u1 = new KullaniciBad("A");
const u2 = new KullaniciBad("B");
console.log(u1.selamla === u2.selamla); // false — iki farklı fonksiyon!
// 1000 kullanıcı = 1000 kopya fonksiyon → bellek israfı

// ✅ DOĞRU — metodu prototype'a eklemek
function KullaniciGood(ad) {
  this.ad = ad;
}

KullaniciGood.prototype.selamla = function () {
  return `Merhaba, ben ${this.ad}`;
};

const u3 = new KullaniciGood("A");
const u4 = new KullaniciGood("B");
console.log(u3.selamla === u4.selamla); // true — aynı fonksiyon!
// 1000 kullanıcı = 1 fonksiyon → bellek verimli