JavaScript Class Terimler Sözlüğü
JavaScript Class Glossary
Bu bölümdeki terimleri ezberlemenize gerek yoktur; konular içinde geçen kavramları daha rahat takip etmeniz için listelenmiştir.
Nesne yönelimli programlamada, benzer özelliklere ve davranışlara sahip objeleri oluşturmak için kullanılan şablon veya kalıp yapısıdır.
Sınıftan bir obje örneği oluşturulduğunda otomatik olarak çalışan özel metot; objenin başlangıç durumunu ayarlar.
Bir sınıftan new anahtar kelimesiyle oluşturulan, sınıfın şablonuna göre yaratılmış
bireysel obje örneğidir.
Sınıfın kendisine ait olan, obje örneği oluşturulmadan kullanılabilen üyeler (metotlar veya alanlar).
Bir sınıfın başka bir sınıftan özelliklerini ve metotlarını miras alması; extends
anahtar
kelimesiyle gerçekleşir.
Bir sınıfın başka bir sınıftan miras alacağını belirten anahtar kelime; prototip zincirini otomatik olarak kurar.
Alt sınıfta üst sınıfın constructor'ını çağırmak (super()) veya metotlarına erişmek
(super.method()) için kullanılan referans.
JavaScript'te objelerin metotlarını ve özelliklerini paylaştığı zincir yapısı; class yapısı arka planda prototip mekanizmasını kullanır.
Alt sınıfta üst sınıftaki bir metodu aynı isimle yeniden tanımlayarak, alt sınıfa özgü davranış sağlama işlemi.
Veri ve metotların bir sınıf içinde birleştirilmesi; private alanlar (#) ile iç verilerin dış erişimden korunması.
# sembolüyle tanımlanan, yalnızca sınıf içinden erişilebilen özellikler; dış erişim dil
seviyesinde engellenir.
Sınıf gövdesinde tanımlanan, dışarıdan doğrudan erişilebilen özellikler; constructor'dan önce otomatik olarak atanır.
class anahtar kelimesiyle doğrudan tanımlanan sınıf; hoisting yoktur, tanımlandıktan
sonra
kullanılabilir.
Bir değişkene atanan sınıf tanımı; dinamik sınıf üretimi veya isimsiz sınıf oluşturma için kullanılır.
Özellik gibi erişilen (get) veya atanan (set) metotlar; veri kontrolü ve
dönüşümü için kullanılır.
Farklı sınıflardan türetilen objelerin aynı metoda farklı şekillerde yanıt vermesi; method overriding ile sağlanır.
Sınıflar (Classes) Yapısı ( Ana Konu Giriş )
Nesneler,
bilgiyi parçalamak yerine
bir arada tutmayı amaçlar.
İlgili veriler ve işlemler tek bir yapı altında toplanarak
kodun hem okunmasını hem de yönetilmesini kolaylaştırır.
Bu bölümde, nesnelerin JavaScript’te nasıl tanımlandığını ve
pratikte nasıl kullanıldığını adım adım inceleyeceğiz.
JavaScript Class Yapısı Modern Mimari Standartları
Modern JavaScript ekosisteminde class anahtar kelimesi, nesne yönelimli programlama ilkelerini uygulamanın en standart ve mimari açıdan en temiz yoludur.
Bu yapı, geçmişteki dağınık yapıcı fonksiyonları ve karmaşık prototip yönetimini tek bir deklaratif blok altında birleştirerek, kodun okunabilirliğini ve yapısal tutarlılığını zirveye taşır.
Karmaşıklık Yönetimi ve SoyutlamaSınıflar, büyük ölçekli uygulamaların yönetiminde kritik rol oynayan soyutlama ve kapsülleme ilkelerini, geliştiriciye manuel prototip müdahalesi gerektirmeden sunar.
Artık bir mühendis, dilin alt seviye mekaniğiyle ( nasıl yapıldığı ) uğraşmak yerine, doğrudan iş mantığı ve nesne davranışı
( ne yapıldığı ) üzerine odaklanma özgürlüğüne sahiptir.
Kurumsal Yazılım Standartlarına GeçişBu söz dizimsel yalınlık, JavaScript'i kurumsal yazılım geliştirme standartlarına taşıyan en önemli adımdır.
Sınıf yapısı, ekipler arası çalışmada kodun niyetini açıkça belli eder; mülklerin nerede tanımlandığı ve metotların nasıl organize edildiği kristal netliğinde bir yapıya kavuşur. Bu, projenin sürdürülebilirliğini artıran felsefi bir disiplindir.
Sonuç olarak, JavaScript Class yapısı, kodun rastgele büyümesini engelleyen bir mimari rehberdir.
Nesne mülklerini ve metotlarını tek bir çatı altında disipline etmek, yazılımın okunabilirliğini ve mimari güvenliğini garanti altına alan en etkili modern yöntemdir.
Sınıf Bildirimi (class Keyword) Söz Dizimi, Güvenlik Protokolleri ve Deklaratif Bütünlük
Bir sınıfın tanımlanması class anahtar kelimesi ile başlatılır.
JavaScript ekosisteminde bu yapıların isimlendirilmesinde PascalCase formatı ( AkilliEvSistemi , StokTakibi gibi ) mutlak bir standart olarak kabul edilir.
Bu adlandırma disiplini, sınıf tanımlarını sıradan fonksiyon ve değişkenlerden ayıran, kodun taranabilirliğini artıran kritik bir görsel mutabakattır.
Deklaratif Yapı ve Kavramsal TekillikClass yapısı, bir nesne şablonunun anatomisini net bir şekilde beyan eden tekil bir kod bloğudur. ES5 döneminde karşılaşılan, mülklerin yapıcı fonksiyon içinde, metotların ise dışarıda .prototype üzerinde tanımlandığı dağınık yapı, yerini bu bütünsel modele bırakmıştır.
Geliştirici artık bir nesnenin hem niteliklerini hem de davranışlarını tek bir bakışta, aynı blok içerisinde görebilir.
Bu yapısal kümeleme, zihinsel yükü azaltarak nesne modelinin kavramsal bütünlüğünü korur.
Güvenlik Mekanizması ve Sıkı DenetimTeknik olarak sınıflar birer fonksiyon ifadesi gibi çalışsa da, yerleşik bir güvenlik mekanizmasına sahiptirler: new anahtar kelimesi olmadan çağrılamazlar.
Geleneksel fonksiyonlarda unutulan bu anahtar kelime, this bağlamının küresel objeye sızmasına ve telafisi güç hatalara yol açarken, class yapısı bu riski motor seviyesinde bir hata fırlatarak engeller.
Ayrıca, sınıflar her zaman otomatik olarak Sıkı Mod ( Strict Mode ) altında çalışır. Bu, değişkenlerin tanımlanma zorunluluğu ve hatalı atamaların sessizce geçiştirilmemesi gibi disiplinli kod kurallarını varsayılan hale getirir.
Hoisting Kısıtlaması ve Mantıksal AkışFonksiyon bildirimlerinin aksine, sınıflarda Hoisting'e uğrar ancak TDZ nedeniyle erişilemez.
Bir sınıf, tanımlandığı satırdan önce kod içinde kullanılamaz; bu durum Temporal Dead Zone olarak adlandırılır.
Bu kısıtlama, kodun yukarıdan aşağıya doğru olan mantıksal akışını garanti altına alarak belirsizliği ortadan kaldırır.
Sonuç olarak, class bildirimi JavaScript'te nesne üretimini bir "tesadüf" olmaktan çıkarıp bir "mimari disiplin" haline getirir.
Metotları ve özellikleri tek bir güvenli kümede toplamak, yazılımın hem sürdürülebilirliğini hem de teknik doğruluğunu en üst seviyeye taşır.
class CalisanFabrikasi {
constructor(isim, bolum) {
this.isim = isim; // Dışarıdan gelen dinamik veri
this.bolum = bolum;
this.girisTarihi = new Date().toLocaleDateString('tr-TR'); // Statik ilk değer
}
getUnvan() {
return `${this.isim} - ${this.bolum}`;
}
}
const ali = new CalisanFabrikasi("Ali Veli", "Muhasebe");
console.log(ali.getUnvan()); // Çıktı: Ali Veli - Muhasebe
console.log(ali.girisTarihi); // Çıktı: 10.11.2025 (Örn.)class Siparis {
constructor(urunAdi, birimFiyat, adet) {
this.urunAdi = urunAdi;
this.birimFiyat = birimFiyat;
this.adet = adet;
}
toplamTutar() {
return this.birimFiyat * this.adet;
}
ozet() {
return `${this.urunAdi} (${this.adet} adet) - Toplam: ${this.toplamTutar()} TL`;
}
}
const siparis1 = new Siparis("Klavye", 750, 2);
console.log(siparis1.ozet());
// Çıktı: Klavye (2 adet) - Toplam: 1500 TLYapıcı Metot (constructor) Nesne Yaşam Döngüsünün Başlangıç Noktası ve İlk Durum Yönetimi
Constructor metodu, bir sınıfta bulunabilen en stratejik özel metottur ve sınıfın tüm mimari temelini oluşturur.
Bu özel işlev, bir sınıf örneği (instance) yaratılırken nesnenin başlangıç durumunu kurgulamaktan ve o nesnenin sistem içindeki eşsiz kimliğini inşa etmekten sorumludur.
Otomatik Yürütme ve Yegane Güvenli BölgeConstructor'ın en ayırıcı özelliği, sınıfın yaşam döngüsünde kesinlikle yalnızca bir kez çalıştırılmasıdır.
Bir sınıfın örneği new SınıfAdı(...) ifadesiyle tetiklendiği anda, JavaScript motoru hiçbir dış müdahale beklemeksizin bu metodu icra eder.
Bu tekillik, nesne mülklerinin ilk değerlerini atamak ve tüm zorunlu konfigürasyonları gerçekleştirmek için sistemdeki tek güvenli limandır.
Constructor çalışmaya başladığı an, new operatörünün oluşturduğu ham nesne, metot içindeki this anahtar kelimesine sıkıca bağlanır; bu, nesneye veri yazılmadan önceki en kritik hazırlık aşamasıdır.
Veri Bütünlüğü ve Geri Dönüş KurallarıConstructor'ın birincil rolü, dışarıdan gelen parametreleri nesneye kalıcı mülkler olarak atayarak nesnenin "hafızasını" oluşturmaktır.
Bu aşamada tanımlanmayan bir özellik, ilerleyen süreçte diğer metotlar tarafından çağrıldığında undefined hatalarına yol açabilir.
Teknik bir kural olarak, constructor metodu açıkça bir değer döndürmemelidir. Motor, metot bittiğinde this objesini otomatik olarak geri döndürür.
Bu, geliştiricinin her new çağrısından sonra tutarlı bir nesne örneği almasını garanti altına alan motor seviyesinde bir protokoldür.
Önemli: Kalıtım ve super() GereksinimiEğer bir sınıf başka bir sınıftan türetilmişse, constructor içinde this bağlamına erişmeden önce super() çağrısı yapılması
teknik bir zorunluluktur.
Özetlemek gerekirse, constructor bir sınıfın giriş kapısıdır.
Nesnenin tüm karakteristik özelliklerini [v_1, v_2, ..., v_n] formunda burada mühürlemek, uygulamanın geri kalanında veri tutarlılığını ve çalışma zamanı güvenliğini sağlar.
class Urun {
constructor(ad, fiyat) {
this.ad = ad;
this.fiyat = fiyat;
}
getFiyat() {
return this.fiyat;
}
}
const laptop = new Urun("Laptop", 15000);
console.log(laptop.getFiyat()); // Çıktı: 15000class Ayarlar {
constructor(tema = 'light', dil) {
// Veri Doğrulama (Validation)
if (!['light', 'dark'].includes(tema)) {
throw new Error("Geçersiz tema belirlendi!");
}
this.tema = tema;
this.dil = dil || 'tr'; // Parametre yoksa 'tr' ata
}
}
const ayar1 = new Ayarlar('dark');
console.log(ayar1.dil); // Çıktı: tr
/* ❌ Hata Yönetimi
const ayar2 = new Ayarlar('kırmızı');
// Hata: Geçersiz tema belirlendi!
*/class Kullanici {
constructor(ad) {
this.ad = ad;
}
}
class Admin extends Kullanici {
constructor(ad, yetki) {
super(ad); // ZORUNLU
this.yetki = yetki;
}
}
const admin1 = new Admin("Göktuğ", "tam");
console.log(admin1.ad); // Göktuğ
console.log(admin1.yetki); // tamÖrnek Metotları (Instance Methods) Paylaşılan Davranışlar ve Akışkan Metot Zinciri Yönetimi
Sınıf gövdesinde tanımlanan Örnek Metotları, bir sınıftan türetilen tüm nesnelerin ortak yeteneklerini temsil eden kritik bileşenlerdir.
Bu metotlar, nesnenin sadece bir "veri yığını" olmasından öte, sistem içinde aktif birer aktör gibi davranmasını, kendi iç durumunu güncellemesini ve dış dünyaya anlamlı sonuçlar üretmesini sağlar.
Otomatik Prototip Ataması ve Bellek VerimliliğiModern sınıf yapısının getirdiği en stratejik fayda, metotların otomatik olarak prototip nesnesine bağlanmasıdır.
Geleneksel yapılarda metotlar her yeni örnekte bellekte tekrar tekrar oluşturulurken, sınıflarda bu metotlar tek bir kopya olarak prototip zincirinde saklanır.
Tüm nesne örnekleri, kendi gövdelerinde bu metodu barındırmak yerine, ortak bir tanıma referans verirler.
Bu mekanizma, binlerce nesnenin oluşturulduğu senaryolarda bellek israfını engelleyen yerleşik bir optimizasyon harikasıdır.
Geliştirici, artık karmaşık prototip atama söz diziminden kurtulmuş, sadece metodun adını ve mantığını yazmaya odaklanmıştır.
this Bağlamı ve Akışkan Arayüz (Method Chaining)Örnek metotlarının ruhu, this anahtar kelimesiyle kurduğu bağdadır.
Bir metot çağrıldığında, içindeki this doğrudan o anki işleme dahil olan nesne örneğine (instance) kilitlenir, bu sayede her metot, sadece kendi nesnesinin verilerini manipüle eder.
Modern mimaride metotların sonunda return this; ifadesinin kullanılması, Akışkan Arayüz denilen güçlü bir tasarım desenini mümkün kılar.
Bu teknik, birden fazla işlemin tek bir satırda art arda dizilmesini sağlayarak, kodun teknik bir listeden ziyade akıcı bir hikaye gibi okunmasına imkan verir.
Sonuç olarak Örnek Metotları sınıf mimarisinin aksiyon merkezidir.
Karmaşık operasyonları \(\left[m_1, m_2, \dots, m_n\right]\) şeklinde zincirlenebilir birer yapıya dönüştürmek, yazılımın bellek performansını korurken, geliştiricinin kodu daha sezgisel bir şekilde yönetmesini sağlar.
class Sayaç {
constructor(baslangic = 0) {
this.deger = baslangic;
}
artir() {
this.deger++; // İç durumu değiştirir
}
oku() {
return this.deger;
}
}
const s1 = new Sayaç(5);
const s2 = new Sayaç(10);
s1.artir();
s2.artir();
console.log(s1.oku()); // Çıktı: 6
// Hem s1 hem de s2, aynı 'artir' metot tanımını prototipten paylaşır.class Islemci {
constructor(baslangic = 0) {
this.sonuc = baslangic;
}
ekle(deger) {
this.sonuc += deger;
return this; // 👈 Zincirleme için kritik
}
carp(deger) {
this.sonuc *= deger;
return this;
}
}
// Zincirleme kullanım (Fluent Interface)
const hesap = new Islemci(5);
const nihaiSonuc = hesap.ekle(10).carp(2).sonuc;
console.log(nihaiSonuc); // Çıktı: 30Public Class Fields (Açık Alanlar) Deklaratif Veri Tasarımı ve Nesne Örneği Yönetimi
Modern JavaScript standartlarında Public Class Fields, bir sınıfın içsel durumunu tanımlarken constructor bloğuna olan bağımlılığı minimize eden deklaratif bir yöntemdir.
Bu alanlar, sınıfın en üst seviyesinde tanımlanarak doğrudan nesne örneğine ( instance ) atanır ve dış dünyadan herhangi bir kısıtlama olmaksızın erişilebilir durumdadır, bu, nesne modellemesinde "açık veri protokolü" ilkesini temsil eder.
Yapısal Optimizasyon ve Yapıcı Metot VerimliliğiSınıf alanlarının en kritik avantajı, varsayılan değerlerin atanması sırasında ortaya çıkar.
Sabit değerler için yapıcı metot içerisinde manuel atama yapma zorunluluğunu ortadan kaldırır.
Bu yaklaşım, constructor bloğunun iş yükünü hafifleterek, bu metodun sadece dışarıdan gelen dinamik parametrelerin işlenmesine ve
bağımlılık enjeksiyonuna odaklanmasını sağlar.
Sonuç olarak, Public Class Fields kullanımı, kodun sadece teknik doğruluğunu değil, aynı zamanda görsel temizliğini ve
bakım kolaylığını da artırır.
Yazılımın niyetini daha deklaratif bir şekilde ortaya koyan bu yöntem, kurumsal seviyedeki projelerde mülk yönetimini disipline eden en etkili modern araçlardan biridir.
Private Class Fields (Özel Alanlar) Veri Gizliliği, Erişim Denetimi ve Mimari Koruma Protokolleri
Private Class Fields, nesne yönelimli programlamanın temel direği olan Kapsülleme (Encapsulation) ilkesini JavaScript ekosisteminde donanım seviyesinde uygulayan en önemli güvenlik adımıdır.
Bu özellik, bir nesnenin iç mantığını ve hassas verilerini dış dünyadan tamamen izole ederek, yazılımın mimari bütünlüğünü ve
durum tutarlılığını en üst seviyeye taşır.
# Sembolü ve Zorunlu Erişim KısıtlamasıBir özelliğin adının önüne eklenen # ( hash ) sembolü, o alanın sadece sınıfın kendi sınırları içerisinde var olabileceğini dikte eder.
Bu, yazılımsal bir tercihten ziyade dil seviyesinde bir erişim bariyeridir.
Geliştirici, sınıf dışından bir referansla this.#ozelVeri yapısına erişmeye çalıştığında, motor seviyesinde bir SyntaxError tetiklenir.
Bu durum, hatalı erişim denemelerinin henüz çalışma aşamasına gelmeden engellenmesini sağlar.
Sonuç olarak, Private Fields kullanımı, bir nesnenin iç işleyişini dış dünyadan saklayarak "Siyah Kutu" ( Black Box ) prensibini hayata geçirir.
Bu mekanizma, sadece veriyi saklamakla kalmaz; aynı zamanda geliştiricinin, nesnenin dışa bakan arayüzünü daha temiz ve kontrollü bir şekilde tasarlamasına rehberlik eden felsefi bir disiplindir.
class Bildirim {
// Public Alanlar (Constructor'dan önce atanır)
gonderildi = false;
sayac = 0;
constructor(mesaj) {
this.mesaj = mesaj; // Constructor'da yalnızca dinamik veri atanır
}
}
const b1 = new Bildirim("Yeni görev atandı.");
console.log(b1.gonderildi); // Çıktı: false
b1.gonderildi = true; // Dışarıdan kolayca değiştirilebilir.class PersonelMaasi {
#maas = 0; // 👈 Private alan, dışarıdan erişilemez
constructor(ilkMaas) {
this.#maas = ilkMaas;
}
zamYap(oran) {
this.#maas *= (1 + oran);
}
// Public Getter metodu ile değeri güvenli bir şekilde gösterir
getMaas() {
return this.#maas;
}
}
const ahmet = new PersonelMaasi(50000);
ahmet.zamYap(0.10);
console.log(ahmet.getMaas()); // Çıktı: 55000
/* ❌ Hatalı Erişim Denemesi
console.log(ahmet.#maas);
// Hata: Syntax Error (Dilin kendisi erişimi engeller)
*/Kalıtım (Inheritance) Extends ve Super Kullanımı
Nesne Yönelimli Programlama'nın dört ana sütunundan biri olan kalıtım, mevcut bir sınıfın yeteneklerini başka bir sınıfa aktararak kodun sürdürülebilirliğinisağlayan bir genişletme mekanizmasıdır.
Bu felsefe, sınıflar arasında "is-a" ( bir ... dır ) ilişkisi kurar.
Örneğin: bir "Yönetici" aslında bir "Personel"dir veya bir "SSD", teknik olarak bir "Depolama Birimi"dir.
Bu hiyerarşi, alt sınıfların üst sınıftaki tüm özellikleri miras alarak üzerine spesifik davranışlar eklemesine olanak tanır.
Tarihsel Zorunluluk ve ES6 DevrimiJavaScript ekosisteminde kalıtım, ES5 döneminde call(), Object.create() ve manuel prototip onarımı gerektiren, hata yapmaya oldukça müsait bir yapıdaydı.
Modern extends ve super anahtar kelimeleri, bu karmaşık süreci deklaratif bir seviyeye indirgemiştir.
Artık prototip zincirinin kurulumu dil motoru tarafından otomatikleştirilerek, geliştiricinin mimari güvenliğeve mantıksal akışa odaklanması sağlanmıştır.
Tüm bunların olarak kalıtım, yazılım mimarisini atomik parçalardan karmaşık sistemlere doğru inşa etmemizi sağlar.
Extends ve super ikilisi, bu süreci standardize ederek ekipler arası çalışmada kodun niyetini netleştirir ve sistemdeki mantıksal tutarlılığı garanti altına alır.
Kalıtım Esnekliği ve Zincir Mekanizması Statik Miras, Fonksiyonel Uyumluluk ve Prototip Sınırları
JavaScript'te extends kullanımı, sadece sınıflar arası bir bağ kurmakla kalmaz; arka planda çift yönlü bir prototip zinciri inşa eder.
Bu otomasyon, alt sınıfın hem örnek metotlarını hem de statik metotlarını (static methods) üst sınıftan sorunsuz bir şekilde devralmasını garanti eder.
Bu mekanizma sayesinde, SubClass.prototype üst sınıfın prototipine bağlanırken, SubClass'ın kendisi de doğrudan üst sınıfın kendisine bağlanır.
Bu hiyerarşik yapı, statik yardımcı fonksiyonların (utility functions) sınıf hiyerarşisi boyunca korunmasını sağlayan mimari bir sürekliliktir.
Esnek Kalıtım: İfadelere Dayalı TüretmeJavaScript'in kalıtım modeli, diğer katı dillerin aksine oldukça esnektir.
Extends anahtar kelimesi sadece sınıfları değil, çalışma zamanında bir yapıcı döndüren herhangi bir geçerli ifadeyi de kabul eder.
Bu esneklik, modern sınıfların eski yapıcı fonksiyonlardan miras almasına olanak tanıyarak, kurumsal projelerde legacy sistemlerin modern mimariye entegrasyonunu kolaylaştırır.
Sonuç olarak, SistemMimarisi içerisinde kalıtım, statik ve dinamik verilerin hiyerarşik akışını kontrol eden çok yönlü bir disiplindir.
Esnek kalıtım ve otomatik zincirleme mekanizmaları, JavaScript geliştiricisine hem geçmişin kod tabanlarını koruma hem de geleceğin izole sistemlerini tasarlama özgürlüğü verir.
Yapıcı Metot Zinciri ve Çalışma Dinamiği this Bağlanması, Argüman Akışı ve Varsayılan Yapılandırma<< /span>
Teknik açıdan super() çağrısı, JavaScript kalıtım hiyerarşisinde iki hayati fonksiyonu aynı anda icra eder: this Yaratımı ve Bağlam Transferi.
Üst sınıfın yapıcı metodu tetiklendiğinde, yeni nesne örneği bellekte oluşturulur.
Bu yeni nesne, otomatik olarak alt sınıfın this bağlamına mühürlenir. Böylece üst sınıfta tanımlanan tüm mülkler, alt sınıfa ait olan objeye doğrudan enjekte edilir.
Argüman Senkronizasyonu ve Veri AktarımıFonksiyon olarak super() fonksiyonu, üst sınıfın ihtiyaç duyduğu tüm dış parametreleri taşıyan bir köprü vazifesi görür.
Eğer üst sınıf constructor'ı belirli argümanlar bekliyorsa, bu veriler alt sınıftan super(param1, param2) şeklinde eksiksiz iletilmelidir.
Bu veri akışı, nesne hiyerarşisinde durum tutarlılığını sağlar; yani bir alt sınıf örneği oluşturulduğunda, onun "genetik mirası" olan üst sınıf özellikleri de doğru verilerle ilklendirilmiş olur.
Sonuç olarak, super() mekanizması nesnenin genetik kodlarının alt katmanlara hatasız kopyalanmasını sağlayan bir iletim protokolüdür.
Bu otomasyon, JavaScript'i karmaşık sistem tasarımlarında hem esnek hem de mimari açıdan güvenli kılarak sürdürülebilir bir geliştirme ortamı sunar.
// Üst Sınıf (Base Class)
class Hayvan {
constructor(ad) {
this.ad = ad;
}
// Bu metot Hayvan.prototype'dadır.
sesCikar() {
return "Bilinmeyen bir ses...";
}
}
// Alt Sınıf (Subclass)
class Kedi extends Hayvan {
// Kedi sınıfında sesCikar metodu tanımlı OLMASA bile miras alır.
constructor(ad, renk) {
super(ad); // Üst sınıf constructor'ı zorunlu çağrı
this.renk = renk;
}
}
const minnos = new Kedi("Minnoş", "Gri");
// Miras alınan metot çağrısı:
console.log(minnos.sesCikar()); // Çıktı: Bilinmeyen bir ses...
console.log(minnos.ad); // Çıktı: Minnoşclass TemelKullanici {
constructor(kullaniciAdi) {
this.kullaniciAdi = kullaniciAdi;
this.rol = "Kullanici";
}
}
class Admin extends TemelKullanici {
constructor(kullaniciAdi, seviye) {
// 1. Üst sınıfın ihtiyacı olan 'kullaniciAdi' parametresi ile çağrılır.
super(kullaniciAdi);
// 2. 'super(..)' çağrıldıktan sonra 'this' kullanılabilir.
this.seviye = seviye;
}
}
const yonetici = new Admin("coder21", 5);
console.log(yonetici.kullaniciAdi); // Çıktı: coder21 (Miras alındı)
console.log(yonetici.rol); // Çıktı: Kullanici (Miras alındı)
console.log(yonetici.seviye); // Çıktı: 5 (Alt sınıfa özel)// super() Çağrısı Öncesi this Kullanımı Hatası
class AnaSinif {
constructor(deger) {
this.deger = deger;
}
}
class HataUretenSinif extends AnaSinif {
constructor(deger) {
// ❌ HATA NOKTASI: 'this' objesi henüz oluşturulmadı.
this.yeniDeger = deger;
// super() çağrısı, bu 'this' atamasından SONRA yapıldığı için hata oluşur.
super(deger);
}
}
/* Çalıştırıldığında oluşan hata:
try {
new HataUretenSinif(1);
} catch (e) {
console.error(e.name);
// Çıktı: ReferenceError: Must call super constructor before accessing 'this'
}
*/// Varsayılan constructor Davranışı (Constructor Tanımlanmadığı Durum)
class Ev {
constructor(adres, odaSayisi) {
this.adres = adres;
this.odaSayisi = odaSayisi;
}
goster() {
return `${this.odaSayisi} odalı, ${this.adres} adresindeki ev.`;
}
}
// Alt Sınıf: Kendi constructor'ı YOK.
class Villa extends Ev {
// JavaScript motoru buraya: 'constructor(...args) { super(...args); }' ekler.
getHavuz() {
return "Bu villada özel havuz mevcuttur.";
}
}
// Kullanım: Üst sınıfın parametreleri alt sınıfa doğrudan aktarılır.
const yazlik = new Villa("Antalya Kıyı", 6);
console.log(yazlik.goster()); // Çıktı: 6 odalı, Antalya Kıyı adresindeki ev. (Miras alınan metot)
console.log(yazlik.adres); // Çıktı: Antalya Kıyı (Otomatik super() sayesinde)Üst Sınıf Metotlarına Erişim ve Polimorfizm super.metot(), Davranış Genişletme ve Çok Biçimlilik Analizi
Polimorfizm ( Çok Biçimlilik ), farklı sınıflardan türetilen nesnelerin aynı metot çağrısına kendi özgün yapılarına uygun, farklı yanıtlar verebilme yeteneğidir.
Bu kavram, hiyerarşik sistemlerde "tek bir arayüz, çoklu uygulama" prensibini hayata geçirir.
JavaScript ekosisteminde polimorfizm, alt sınıfların üst sınıftan miras aldıkları davranışları tamamen ezmek yerine, onları akıllıca genişletmesine olanak tanıyarak mimari esnekliği garanti altına alır.
super.metot() ile Fonksiyonel Devamlılıksuper.metotAdı() söz dizimi, bir alt sınıfın üst sınıftaki orijinal mantığı koruyarak üzerine yeni yetenekler eklemesini sağlayan en kritik araçtır.
Bu yapı, kod tekrarını minimuma indirirken, üst sınıftaki temel mantığın merkezi olarak güncellenmesine imkan tanır.
Böylece bir mühendis, bakım maliyetini düşürürken sistemin genel kararlılığını koruma altına almış olur.
Özet olarak, super.metot() kullanımı, alt sınıfları "asi evlatlar" olmaktan çıkarıp, üst sınıfın mirasına sadık kalarak kendi uzmanlık alanlarını geliştiren nitelikli modüllere dönüştürür.
Bu disiplin, modern yazılım mimarisinde mimari güvenliği ve kodun okunabilirliğini garanti altına alan en güçlü yapı taşlarından biridir.
Kavramsal Köprü: super() ve super.metot() Fonksiyonel Çağrı ve Prototip Referansı Ayrımı
super anahtar kelimesi, JavaScript'in kalıtım mekanizmasında iki farklı ve teknik olarak kesin çizgilerle ayrılmış role hizmet eder.
Bu ayrım, dilin çalışma prensibini anlamak için esastır; çünkü super, kullanıldığı bağlama göre ya bir yapıcı fonksiyon ya da bir
prototip referansı olarak davranır.
super(): Yapıcı Fonksiyon ÇağrısıYalnızca alt sınıfın constructor metodu içinde kullanılan super(), teknik karşılığıyla bir Fonksiyon Çağrısıdır (Constructor Invocation).
Bu kullanımın birincil sorumluluğu, üst sınıfın yapıcı metodunu işleterek alt sınıfın this objesini bellekte yaratmaktır.
Bu çağrı gerçekleşene kadar nesne örneği teknik olarak var olamaz.
Bu süreç, nesnenin veri üyelerinin en temel seviyede başlatılmasını sağlayan ontolojik bir gerekliliktir.
Sonuç olarak, super'in bu iki farklı formu arasındaki net ayrım, geliştiricinin ne zaman nesneyi inşa ettiğini ve ne zaman mevcut bir davranışa başvurduğunu anlamasını sağlar.
Bu kavramsal köprü, JavaScript sınıflarını sadece bir "söz dizimi" olmaktan çıkarıp, bellekte ve prototip zincirinde deterministi bir hiyerarşi kuran güçlü bir mühendislik aracına dönüştürür.
Metot Ezme (Overriding) ve Genişletme (Augmentation) Polimorfizm, Davranışsal Miras ve Bağlam Yönetimi
Metot Ezme ( Overriding ), bir alt sınıfın üst sınıftan miras aldığı bir metodu aynı isimle yeniden tanımlayarak, o davranışın alt sınıfa özgü bir kimlik kazanmasını sağlama sürecidir.
Bu senaryoda, nesne üzerinden metot çağrıldığında JavaScript motoru prototip zincirindeki en yakın tanımı çalıştırır.
Bu, polimorfizmin temelidir; ancak üst sınıfın orijinal mantığına hala ihtiyaç duyulduğunda super.metotAdı() devreye girer.
Genişletme (Augmentation): Katmanlı Mantık TasarımıGenişletme , alt sınıfın üst sınıf mantığını tamamen yok saymak yerine, onun üzerine yeni işlevsellikler eklediği en verimli tasarım desenidir.
Alt sınıf, kendi kodunu yürütmeden önce veya sonra super.metotAdı() çağrısı yaparak temel işleyişi tetikler.
Bu yaklaşım, DRY ilkesini koruyarak loglama, veri doğrulama veya ek güvenlik katmanları eklemek için mimari bir standart sunar.
Sonuç olarak, metot ezme ve genişletme mekanizmaları, yazılımın esnekliğini ve bakım kolaylığını doğrudan etkileyen unsurlardır.
super referansı üzerinden kurulan bu köprü, sınıflar arası iletişimi güvenli hale getirirken sistemin hiyerarşik bir disiplin içerisinde büyümesini garanti altına alır.
class Hesap {
constructor(bakiye) {
this.bakiye = bakiye;
}
goster() {
return `Hesap Tipi: Standart - Bakiye: ${this.bakiye} TL.`;
}
}
class TasarrufHesabi extends Hesap {
constructor(bakiye, oran) {
super(bakiye);
this.oran = oran;
}
// Üst sınıftaki 'goster' metodu eziliyor (override).
goster() {
// super.goster() ile üst sınıfın orijinal çıktısı alınıyor.
const temelCikti = super.goster();
// Üst sınıf çıktısı, alt sınıfa özel bilgiyle birleştiriliyor.
return temelCikti + ` | Yıllık Faiz Oranı: %${this.oran}.`;
}
}
const tasarruf = new TasarrufHesabi(50000, 5);
// Metot, alt sınıftaki genişletilmiş versiyonu çalıştırır (Polimorfizm):
console.log(tasarruf.goster());
// Çıktı: Hesap Tipi: Standart - Bakiye: 50000 TL. | Yıllık Faiz Oranı: %5class Kontrolcu {
constructor(aktif) {
this.aktif = aktif;
}
calistirılabilirMi() {
return this.aktif; // Temel kontrol: Aktif mi?
}
}
class YoneticiKontrolcusu extends Kontrolcu {
constructor(aktif, rol) {
super(aktif);
this.rol = rol;
}
// Üst sınıf metodu eziliyor ve genişletiliyor.
calistirılabilirMi() {
// Önce üst sınıfın temel kontrolünü yap (false ise devam etme).
if (!super.calistirılabilirMi()) {
return false;
}
// Alt sınıfa özel, ek mantık ekle.
return this.rol === 'ADMIN' ? true : false;
}
}
const kullanici = new YoneticiKontrolcusu(true, 'USER');
const admin = new YoneticiKontrolcusu(true, 'ADMIN');
console.log(kullanici.calistirılabilirMi()); // Çıktı: false
console.log(admin.calistirılabilirMi()); // Çıktı: trueStatic Metotlar Nesne Bağımsızlığı, Yardımcı Araç Setleri ve Fabrika Tasarım Desenleri
Sınıf yapısının temelini oluşturan mülkler ve metotlar, standart bir tasarımda yalnızca sınıftan türetilen
bireysel nesne örneklerine aittir ve bunlara this anahtar kelimesiyle erişilir.
Ancak static anahtar kelimesi, bu kuralı kökten değiştirerek üyelerin doğrudan sınıfın kendisine mühürlenmesini sağlar.
Bu, bellekte nesne örneği için yer ayrılmadan önce bile o fonksiyonun veya verinin sınıf kimliği üzerinden erişilebilir olması anlamına gelir.
Felsefi Temel: Sınıfı Yardımcı Araç Kutusu Olarak KullanmaStatik üyelerin varlık felsefesi, o sınıfın işlevselliğinin bir nesne örneği yaratılmadan da kullanılabilmesidir.
Bu yaklaşım, sınıfı bir "kalıp" (blueprint) olmaktan çıkarıp, onu objenin kendisinden bağımsız işlevsellikler için bir merkezi araç kutusu veya yapılandırma deposuna dönüştürür.
Yardımcı İşlevler (Utility Functions)Bir işlevin sınıfın içindeki dinamik verilere (this.ozellik) ihtiyacı yoksa, ancak mantıksal ve kavramsal olarak o konuyla ilgiliyse statik tanımlanmalıdır.
Örneğin:Bir SistemYardimcisi sınıfının tarih formatlama veya veri doğrulama metodu statik olmalıdır; çünkü bu işlemler için her seferinde yeni bir nesne belleğe yüklemek mimari açıdan maliyetli ve gereksizdir.
Sonuç olarak, static üyeler, yazılım mimarisinde kaynak yönetimini optimize eden ve kodun hiyerarşik düzenini güçlendiren bir disiplindir.
Sınıfı sadece bir veri şablonu olmaktan çıkarıp, onu sistemin ihtiyaç duyduğu mantıksal bir operasyon merkezine dönüştürerek sürdürülebilir bir geliştirme altyapısı sunar.
Statik Metotlar: Teknik Ayrım ve Bellek Yönetimi Bellek Optimizasyonu, Bağlamsal Kısıtlamalar ve Miras Zinciri
Statik ve örnek (instance) üyeler arasındaki ayrım, JavaScript motorunun bellek yönetiminde ve nesne erişim kurallarında temel bir mimari farklılık yaratır.
Üyelerin bellekte fiziksel olarak nerede konumlandığı, hem bellek verimliliğini hem de erişim hiyerarşisini belirler.
Örnek Üyeler: Metotlar prototip zinciri ( SınıfAdı.prototype ) üzerinde depolanırken, özellikler her bir objenin kendisine atanır.
Bu, metotların tüm örnekler arasında paylaşılmasını sağlayarak bellekten tasarruf edilmesini garantiler.
Statik Üyeler: Doğrudan sınıfın kendisine eklenirler.
Bu üyeler, uygulama genelinde tek bir kopya olarak kalır ve bir nesne örneği oluşturulmasına ihtiyaç duymadan, sınıfın varlığıyla birlikte bellekten yerlerini alırlar.
Erişim Protokolleri ve Zorunlu KısıtlamalarFiziksel ayrım, erişim kurallarını da mutlak bir disipline sokar. Statik üyelere erişim her zaman doğrudan sınıf adı üzerinden (SınıfAdı.metot()) gerçekleşir.
Bu üyeler prototip zincirinde bulunmadığı için, bir obje örneği üzerinden çağrılma denemeleri motor seviyesinde bir TypeError ile engellenir.
Örnek üyeler ise o objenin benzersiz durumunu (state) temsil ettiği için yalnızca oluşturulan örnek üzerinden erişilebilirdir.
Statik bağlamda örnek üyelerine erişmek, nesne henüz var olmadığı için mantıksal olarak imkansızdır.
Sonuç olarak, statik ve örnek üyeler arasındaki bu teknik ayrım, kodun hem bellek performansını hem de yapısal güvenliğini optimize eden bir mühendislik kuralıdır.
Statik üyelerin hiyerarşik bir zincir üzerinden miras alınabilmesi, JavaScript'i kurumsal seviyedeki karmaşık sistem tasarımlarında esnek ve tutarlı bir dil haline getirir.
Statik Mimari ve Kontrollü Üretim Fabrika Metotları, Bellek Paylaşımı ve Statik Miras Zinciri
Statik metotların en güçlü kullanım alanlarından biri, nesne yaratma sürecini merkezileştiren ve soyutlayan Fabrika Metotlarıdır.
Bu yaklaşım, new operatörünün doğrudan kullanımını kısıtlayarak, verilen parametrelere göre hangi alt sınıfın ( Admin, Misafir veya Sistem ) oluşturulacağına karar veren akıllı bir denetim mekanizması sunar.
Bu, mimari seviyede nesne yaşam döngüsü yönetimini garanti altına alır.
Statik Bağlamın Teknik YönelimiStatik metotlar içindeki this bağlamı, örnek metotlarından radikal bir şekilde ayrılır. Bir statik metot çağrıldığında, this herhangi bir nesne örneğini değil, doğrudan Sınıfın Yapıcı Fonksiyonunu işaret eder.
Sınıf-İçi İletişim: Bu yönelim, statik bir metot içinden aynı sınıftaki diğer statik bileşenlere ( this.MAX_LIMIT gibi ) doğrudan erişilmesini sağlar.
Erişim Kısıtlaması: Statik metotlar çalışırken bir nesne örneğinin varlığı garanti edilmediği için, this.örnekÖzelliği kullanımı mantıksal olarak imkansızdır. Statik katman, nesne durumundan (instance state) tamamen izole ve bağımsız çalışır .
Statik Alanlar (ES2022): Küresel Veri DeposuModern JavaScript (ES2022) ile gelen Statik Alanlar, sınıfın tüm örnekleri tarafından paylaşılan merkezi değerleri tutan bir mekanizmadır.
Bellek Verimliliği: Her nesne örneği için ayrı bellek tahsisi gerektiren mülklerin aksine, statik alanlar bellekte tek bir kopya olarak saklanır.
Maksimum limitler, yapılandırma anahtarları veya durum kodları gibi tüm sistemde sabit kalması gereken değerlerin yönetimi için en optimize yoldur.
Sonuç olarak, statik mimari; nesne bağımsız işlevleri, küresel yapılandırmaları ve kontrollü üretim modellerini bir araya getiren
mühendislik disiplinidir.
extends ve super ile desteklenen statik zincirleme, JavaScript sınıflarını sadece veri taşıyıcılar olmaktan çıkarıp, kendi kendini yöneten
akıllı sistem modüllerine dönüştürür.
class Hesaplayici {
// Statik Alan (Global Sabit - Tek kopyadır)
static KDV_ORANI = 0.20;
static PI = 3.14159;
// Statik Metot (Utility İşlev - Instance verisine ihtiyaç duymaz)
static kdvEkle(fiyat) {
// Statik metot içinden statik alana erişim
const kdvliFiyat = fiyat * (1 + Hesaplayici.KDV_ORANI);
return Math.round(kdvliFiyat * 100) / 100;
}
}
// Kullanım: Sınıf adı üzerinden doğrudan erişim.
const urunFiyati = 100;
const sonFiyat = Hesaplayici.kdvEkle(urunFiyati);
console.log(`KDV Oranı: %${Hesaplayici.KDV_ORANI * 100}`); // Çıktı: KDV Oranı: %20
console.log(`Son Fiyat: ${sonFiyat}`); // Çıktı: Son Fiyat: 120class Kullanici {
constructor(ad, rol) {
this.ad = ad;
this.rol = rol;
this.girisZamani = new Date();
}
// 💡 Statik Fabrika Metodu: Obje yaratma sürecini kapsüller
static misafirYarat(ad) {
// Belirli varsayılan parametrelerle objeyi oluşturur
return new Kullanici(ad, "Misafir");
}
static yöneticiYarat(ad) {
return new Kullanici(ad, "Admin");
}
}
// Kullanım: new kullanmaya gerek kalmadı, Fabrika metodu parametreleri yönetti.
const misafir = Kullanici.misafirYarat("Ziyaretci");
const admin = Kullanici.yöneticiYarat("Kodcu");
console.log(`${misafir.ad} rolü: ${misafir.rol}`); // Çıktı: Ziyaretci rolü: Misafir
console.log(`${admin.ad} rolü: ${admin.rol}`); // Çıktı: Kodcu rolü: Adminclass VeriIsleyici {
constructor(veri) {
this.veri = veri; // Örnek (Instance) Özelliği
}
static MaxLimit = 100; // Statik Alan (Sınıf Özelliği)
// ❌ Statik metot: Bir obje örneği (instance) gerektirmez.
static getDurum() {
// ✅ Doğru: this (yani VeriIsleyici) statik alana erişir
console.log(`Limit: ${this.MaxLimit}`);
// ❌ Hata: Statik bağlamda 'veri' instance özelliği yoktur.
// console.log(this.veri); // Hata: undefined veya TypeError (Strict mode'da)
}
}
// Statik metot çağrısı, instance yaratılmadan gerçekleşir
VeriIsleyici.getDurum(); // Çıktı: Limit: 100🧭 Opsiyonel Okuma Notu
Bilgilendirme: Bu bölüm, konuların arka planına ve düşünsel temellerine daha derin bir bakış sunmak amacıyla hazırlanmıştır.
- Matematiksel, tarihsel ve felsefî içerikler isteğe bağlı olarak okunabilir.
- Her bölümün içerik seviyesi ve yoğunluğu farklılık gösterebilir.
- Temel düzey kullanıcılar için zorunlu değildir, ileri düzey okuma niteliğindedir.
Sınıflar (Classes) Yapısı ( Felsefi ve Tarihsel Açıklama )
Nesneler,
bilgiyi parçalamak yerine
bir arada tutmayı amaçlar.
İlgili veriler ve işlemler tek bir yapı altında toplanarak
kodun hem okunmasını hem de yönetilmesini kolaylaştırır.
Bu bölümde, nesnelerin JavaScript’te nasıl tanımlandığını ve
pratikte nasıl kullanıldığını adım adım inceleyeceğiz.
Tarihsel Zorunluluk Geleneksel Miras, ES6 Devrimi ve Syntactic Sugar Felsefesi
JavaScript, tasarım felsefesinin merkezinde Prototip Tabanlı Miras modelini benimsemiş bir dildir.
Geleneksel OOP dillerinin ( Java, C++ ) aksine, dilin ilk versiyonlarında yerleşik bir class yapısı bulunmuyordu.
Bu durum, özellikle sınıf tabanlı dillerden gelen geliştiriciler için ciddi bir kafa karışıklığı ve öğrenme bariyeri yaratıyordu. Sınıf benzeri yapılar kurmak isteyen mühendisler, yapıcı fonksiyonları (constructor functions) manuel prototip zinciri yönetimi ile birleştirmek zorundaydı.
Constructor Pattern ve Manuel Prototip YönetimiES6 öncesi dönemde kullanılan Constructor Pattern, kodun okunabilirliğini ve bakımını zorlaştıran parçalı bir yapı sunuyordu.
Bir nesnenin özelliklerini fonksiyonun içinde tanımlarken, davranışlar prototip objesine dışarıdan eklemek, nesnenin bütünlüğünü zayıflatıyordu.
Bu manuel süreç, özellikle kalıtım zinciri büyüdükçe kırılgan kod bloklarına ve hantal bir söz dizimine yol açıyordu. .
Yazılımın mimari özü, prototipler üzerine kurulu olsa da, geliştirici deneyimi bu karmaşıklığın kurbanı oluyordu
Özet olarak, JavaScript Class yapısı, dilin esnek prototip doğasını inkar etmek yerine, onu profesyonel bir mühendislik disiplini altına almıştır.
Bu evrim, modern web uygulamalarının karmaşık nesne hiyerarşilerini güvenli ve sürdürülebilir bir şekilde tasarlamanın önünü açan en kritik tarihsel dönemeçtir.
Geleneksel OOP Entegrasyonu ve Soyutlama Katmanı Kayıp Soyutlama, Kavramsal Boşluk ve Deklaratif Dönüşüm
Geleneksel nesne yönelimli programlama dillerinin temelindeki class kavramı, yalnızca yapısal bir araç değil, aynı zamanda hayati bir soyutlama katmanıdır.
Sınıflar, karmaşık veriyi ve bu veriyi işleyen mantığı tek bir deklaratif yapının içine hapseder.
Bu sayede bir mühendis, objenin iç işleyişiyle ( bellek tahsisi, prototip zinciri navigasyonu ) uğraşmak yerine, doğrudan objenin davranışsal çıktısına ve iş mantığına odaklanma özgürlüğüne sahip olur.
Kurumsal Standartlara EntegrasyonSınıf yapısının sunduğu bu soyutlama, JavaScript'i sadece bir "scripting" dili olmaktan çıkarıp, kurumsal seviyede ölçeklenebilir ve sürdürülebilir sistemler inşa edilebilen profesyonel bir platforma dönüştürmüştür.
Bu hiyerarşik disiplin, ekipler arası çalışmada kodun niyetini kristal netliğinde belli eder ve projenin mimari güvenliğini garanti altına alır.
Yapıcı Fonksiyonlar: Bir Taklit Çözüm Nesne İnisiyalizasyonu, 'new' Operatörü ve Soyutlama Limitleri
JavaScript'in erken dönemlerinde, resmi bir class yapısı olmaksızın nesne şablonları oluşturma ihtiyacı, dilin temel yeteneği olan
Yapıcı Fonksiyonlar ile giderilmiştir.
Bu çözüm, geleneksel bir fonksiyona new anahtar kelimesi ile özel bir rol yüklenmesi temeline dayanır.
Bu anahtar kelime kullanıldığında, JavaScript motoru arka planda dört zorunlu adımı içeren mekanik bir taklit süreci yürütür.
Adım Adım Nesne İnşasıBoş Obje Yaratımı: Motor, bellekte yepyeni ve boş bir nesne yaratır.
Bu, sınıf örneği için bellek tahsisinin ilk fiziksel adımıdır.
This Bağlama (Context Binding): Oluşturulan bu boş nesne, anında fonksiyonun yürütme bağlamına atanır ve fonksiyon içindeki this anahtar kelimesini temsil etmeye başlar.
Özellik Ataması: Fonksiyon gövdesi çalıştırılarak, geliştiricinin tanımladığı tüm veriler this referansı üzerinden yeni objeye mühürlenir; böylece objenin başlangıç durumu kurulur.
Örtülü Geri Dönüş (Implicit Return): Eğer açıkça başka bir obje döndürülmediyse, motor otomatik olarak tüm özellikleri kuşanmış olan this objesini geri döndürür.
Sonuç olarak, yapıcı fonksiyonlar JavaScript'i nesne tabanlı bir dünyaya taşısa da, mimari disiplin açısından dağınık bir yapı sunuyordu.
Modern sınıf yapısı, bu "parçalı" tanımı tek bir blok altında birleştirerek, yazılımın okunabilirliğini ve bakım kolaylığını profesyonel seviyeye taşımıştır.
Soyutlama Kaybının Teknik Sonuçları Karmaşıklık, Ölçeklenebilirlik ve Mimari Enerji Yönetimi Analizi
Yapıcı fonksiyonlar, bir nesneyi başlatma görevini teknik olarak yerine getirse de, Nesne Yönelimli Programlama'nın temel direği olan temiz soyutlamayı başarmakta yetersiz kalmıştır.
bu başarısızlık, doğrudan dilin bellek yönetim şeklinden ve geliştiriciye yüklediği manuel sorumluluktan kaynaklanıyordu. Geliştirici, nesnenin ne yapacağına odaklanmak yerine, prototip zincirinin bellekte nasıl konumlanacağını düşünmek zorunda bırakılıyordu.
Operasyonel Engel ve Bakım MaliyetiBu durum, dili tamamen kullanışsız hale getirmese de, büyük ölçekli ekiplerin ve karmaşık uygulamaların bakımı önünde ciddi bir mimari bariyer teşkil ediyordu.
Kodun hiyerarşik yapısı, fiziksel olarak farklı yerlere dağıldığı için projenin ölçeklenmesi zorlaşıyor ve hata payı artıyordu.
Mühendislik perspektifinden bakıldığında; geliştirici, soyutlama ( ne yapıldığı ) yerine uygulamaya ( nasıl yapıldığı ) gereğinden fazla zihinsel enerji harcıyordu. Bu teknik açmaz, yazılım dünyasında class söz diziminin ortaya çıkışının en güçlü gerekçesi olmuştur.
Sonuç ise, soyutlama kaybı sadece görsel bir dağınıklık değil, aynı zamanda yazılımın sürdürülebilirliğini tehdit eden teknik bir borçtur.
Modern sınıf yapısı, bu karmaşıklığı tek bir çatı altında disipline ederek, geliştiriciyi dilin düşük seviyeli mekaniklerinden kurtarmış ve
mimari güvenliği standart hale getirmiştir.
Bellek İsrafı ve Tekrar Üretim (Recreation) Metot Yerleşimi Sorunu
Soyutlama kaybının teknik düzlemdeki en maliyetli sonucu, sistem kaynaklarının kontrolsüz tüketimi ve bellek israfıdır.
Bir metot, constructor bloğu içerisinde tanımlandığında, her yeni nesne örneğiyle birlikte bu metodun fonksiyon tanımı bellekte
sıfırdan yeniden inşa edilir.
Binlerce Nesne ve Redundant Bellek İşgaliSenaryo gereği bir Personel sınıfından binlerce çalışan nesnesi üretildiğini varsayalım; bu durumda calis() metodu, işlevi her örnekte tamamen aynı olmasına rağmen bellekte binlerce farklı adrese kopyalanır.
Bu durum, büyük ölçekli kurumsal uygulamalarda kabul edilemez bir performans regresyonuna ve gereksiz RAM blokajına yol açarak sistemin ölçeklenebilirliğini doğrudan tehdit eder.
OOP Paylaşım İlkesi ve Prototip İhtiyacıNesne Yönelimli Programlama (OOP) felsefesinin temelinde, bir sınıfa ait davranışların tüm örnekler arasında paylaşılan bir bellek alanı üzerinden yönetilmesi ilkesi yatar.
Geleneksel yapıların bu davranışı kendiliğinden ( out-of-the-box ) sunmaması, geliştiriciyi karmaşık ve hataya açık manuel prototip onarımlarına iten en büyük mimari bariyerdir.
Sonuç olarak, modern class yapısı metotları otomatik olarak prototip zincirine bağlayarak, binlerce nesnenin tek bir metot tanımını paylaşmasını sağlar ve bellek verimliliğini mimari bir standart haline getirir.
Zorunlu Prototip Yönetimi Paylaşımın Bedeli
Bellek israfını minimize etmek ve metotları nesne örnekleri arasında paylaşımlı bir kaynağa dönüştürmek, geliştiriciler için manuel bir mimari yük haline gelmişti.
Bu optimizasyonu sağlamak için metotların, yapıcı fonksiyonun gövdesinden koparılarak harici bir prototype nesnesine enjekte edilmesi zorunluydu.
Prototype nesnesi, nesne hiyerarşisinde tüm örneklerin ortak yeteneklerini barındıran merkezi bir davranış kütüphanesi görevini üstlenir.
Hiyerarşik Referans Zinciri ve __proto__JavaScript motoru, bir nesne örneği üretildiği anda gizli bir bağlantı protokolü olan [[Prototype]] ( kod seviyesinde __proto__) referansını devreye sokar.
Bu referans, nesnenin kendi gövdesinde bulamadığı bir metodu, hiyerarşik bir üst katman olan Constructor.prototype adresinde aramasını sağlayan deterministik bir navigasyon hattıdır.
Teknik sonuç olarak; Prototype zinciri sayesinde binlerce nesne tek bir fonksiyon tanımına referans vererek, sistemin
mimari enerji verimliliğini maksimize eder.
Ancak bu yapının manuel olarak kurulması, kodun deklaratif bütünlüğünü bozarak geliştirme sürecini karmaşıklaştıran tarihsel bir zorunluluktur.
Dağınık Tanım ve Kavramsal Ayrılık Genel Açıklama
Geleneksel yapıcı fonksiyon modelinde bir sınıfın anatomisi, fiziksel olarak parçalanmış bir yapı arz eder; bu durum geliştirici üzerinde yüksek bir bilişsel yük yaratır.
Modern bir mimaride tüm üyelerin tek bir deklaratif blok içinde olması beklenirken, eski modelde nesnenin niteliklerini anlamak için fonksiyon gövdesine, yeteneklerini anlamak için ise dağınık Prototype atamalarına bakmak zorunluydu.
Bu parçalı yapı, kodun mantıksal akışını takip etmeyi zorlaştırarak, nesne şablonunu temiz bir blueprint olmaktan çıkarıp, dosyanın farklı yerlerine yayılmış manuel operasyonlar dizisine dönüştürür.
Kavramsal Bozulma: Kapsülleme (Encapsulation) İhlaliNesne Yönelimli Programlama'nın temel direği olan Kapsülleme, verinin ve o veriyi işleyen mantığın tek bir atomik birim içinde bütünleşmesini emreder.
Yapıcı fonksiyonlardaki bu mekansal ayrılık, kapsülleme ilkesini teknik olarak zayıflatır; zira sınıfın "ne olduğu" ile "ne yaptığı" arasındaki
mantıksal bağ kopmuştur.
Deklaratif Birleşme: Onarılan Mimari GüvenlikModern class söz dizimi, bu iki ayrı konumu (constructor ve prototype) tek bir çatı altında birleştirerek bu kavramsal bozulmayı ortadan kaldırmıştır.
Bu birleşme, JavaScript'in sınıf taklidini sezgisel bir deneyimden profesyonel bir mühendislik disiplinine dönüştüren en kritik yapısal reformdur.
|
Konum
|
İçerik Alanı
|
Stratejik Rolü
|
|---|---|---|
|
Yapıcı Fonksiyon İçi
|
this.ad, this.eposta ( Özellikler )
|
Objenin benzersiz durumunu tanımlar.
Bu değerler her yeni örnek için farklıdır. |
|
Prototype Nesnesi
|
Personel.prototype.metot ( Metotlar )
|
Objenin paylaşılan davranışlarını ( behavior ) tanımlar.
Bu fonksiyonlar tüm objeler tarafından ortaklaşa kullanılır. fonksiyonlar tüm objeler tarafından ortaklaşa kullanılır. |
Alt Sınıf Oluşturma Zorluğu İki Aşamalı Manuel Süreç
Geleneksel sınıf tabanlı dillerin sunduğu yalın kalıtım mekanizması ( extends gibi ), ES5 öncesi JavaScript dünyasında yerini syntactic overhead
( söz dizimsel ağır yük ) olarak adlandırılan karmaşık bir yapıya bırakmıştı.
Yapıcı fonksiyonların kalıtım için kullanılması, bir alt sınıfın ( subclass ) üst sınıftan ( superclass ) miras almasını son derece hata eğilimli ve izlemesi güç bir sürece dönüştürüyordu.
Bir alt sınıfın, üst sınıfın tüm işlevselliğini kusursuzca devralması için geliştiricinin, prototip zincirine doğrudan müdahale etmesi gereken
iki aşamalı, zorunlu ve tamamen manuel bir protokolü takip etmesi şarttı.
İki Aşamalı Manuel Miras Protokolü1. Bağlamsal Bağlantı (Context Linking): İlk adımda alt sınıfın yapıcı metodu içinde, üst sınıfın metodunu .call(this) ile çağırarak mülklerin alt sınıfa enjekte edilmesi sağlanırdı.
2. Prototip Onarımı (Prototype Repair): İkinci ve en kritik adımda ise, alt sınıfın prototip nesnesi Object.create() ile üst sınıfın prototipine bağlanır ve ardından kaybolan constructor referansı manuel olarak geri atanırdı.
Modern Sınıfların Teknik ZorunluluğuModern class yapısının ortaya çıkışını zorunlu kılan en büyük teknik motivasyon, işte bu mimari kırılganlığı ortadan kaldırmaktı.
extends anahtar kelimesi, yukarıdaki tüm manuel adımları tek bir deklaratif beyan ile motor seviyesinde otomatikleştirerek, kalıtımı bir "risk" olmaktan çıkarıp bir standart haline getirmiştir.
Üst Sınıfın Özelliklerini Miras Alma Aşama 1
Bir alt sınıf örneği (instance) inşa edilirken, ilk ontolojik zorunluluk, üst sınıfa ait temel niteliklerin (örneğin this.ad, this.maas) yeni oluşturulan objeye enjekte edilmesidir.
Modern dillerde bu süreç super() çağrısı ile motor seviyesinde otomatikleşmiş olsa da, ES5 dünyasında bu işlem, geliştiricinin bizzat yönettiği
manuel bir fonksiyon bağlama operasyonuydu.
Bağlam Sorunu ve Context SwitchingÜst sınıfın yapıcı fonksiyonunu çağırmak yeterli değildir; bu çağrının alt sınıfın bellek adresinde (bağlamında) yürütülmesi gerekir.
JavaScript'te fonksiyonlar "kaygan bir bağlam" (context) yapısına sahip olduğundan, üst sınıfın fonksiyonu sıradan bir şekilde çağrılırsa this referansı küresel objeye (window) sızar ve sistemde veri kirliliğine yol açar.
Teknik çözüm; üst sınıfın yapıcı metodunu .call() veya .apply() metotlarıyla manipüle ederek, alt sınıfın this bağlamını zorla üst sınıfa aktarmaktı.
Bu süreç, bir fonksiyonun sınıf görevi üstlenirken bile bağlamının ne kadar istikrarsız olduğunu kanıtlar.
Geliştiricinin her kalıtım işleminde dilin iç mekaniklerini elle kontrol etmek zorunda kalması, modern class yapısının sunduğu mimari güvenliğin en büyük gerekçesidir.
Üst Sınıfın Metotlarını Miras Alma (Prototip Zinciri İnşası) Aşama 2
Özelliklerin .call() ile enjekte edilmesinden sonra, sıra nesnenin paylaşılan davranışlarını miras alacağı kalıtımsal navigasyon hattını kurmaya gelir.
Alt sınıfın, üst sınıfın prototipinde ( Personel.prototype gibi ) yer alan metotlara erişebilmesi için, prototip zincirinin bellekte fiziksel olarak yeniden yapılandırılması zorunludur.
Prototip Sıfırlama: Object.create() OperasyonuBu işlemde kullanılan temel araç Object.create() metodudur.
Bu metot, üst sınıfın prototipini temel alan "saf" bir nesne yaratarak alt sınıfın prototipine atar.
Ancak bu "sıfırlama" işlemi, beraberinde ciddi bir mimari yan etki getirir: Alt sınıfın kendi öz kimliğini belirleyen constructor referansı bu süreçte silinir.
Bu durum, geliştiricinin zinciri onarmak için üçüncü bir manuel müdahale yapmasını gerektiren, oldukça kırılgan bir zincirleme bağımlılık yaratır.
Bu iki aşamalı ( ve onarımla birlikte üç adımlı ) süreç, bir yandan kodun okunabilirliğini sıfırlarken, diğer yandan hata yapma olasılığını maksimize eder.
Modern class yapısı, tüm bu "cerrahi" işlemleri extends anahtar kelimesi altında gizleyerek, geliştiricinin sadece iş mantığına odaklanmasını sağlayan kusursuz bir soyutlama katmanı sunar .
Yapıcı Özelliğinin Kaybı (Zorunlu Onarım) Zincirleme Hata
Prototip zincirinin manuel inşası, metot mirasını başarılı bir şekilde sağlasa da, bu müdahale veri bütünlüğünü tehdit eden kritik bir yan etkiyi tetikler: Constructor özelliğinin kaybı.
Her yapıcı fonksiyon, varsayılan olarak kendi prototype nesnesi üzerinde, nesnenin menşeini belirleyen bir referans taşır.
Ancak, Object.create() operasyonu ile alt sınıfın prototipi tamamen yeni bir objeyle değiştirildiğinde, bu orijinal kimlik bilgisi bellekte kaybolur.
Teknik Aksaklık: Yanlış Referans ve Tip KontrolüEğer bu referans kaybı düzeltilmezse, çalışma zamanında bir alt sınıf nesnesi teknik olarak üst sınıfın bir örneğiymiş gibi görünür.
Bu durum, karmaşık sistemlerde hata ayıklamayı zorlaştırırken, instanceof gibi tip kontrollerinin hatalı sonuçlar vermesine ve mimari güvenliğin çökmesine neden olur.
Zorunlu Onarım: Üçüncü Manuel MüdahaleBu veri bütünlüğü sorununu gidermek için geliştiricinin üçüncü ve son bir manuel adım atması gerekir: Kaybolan referansın alt sınıfın yapıcı fonksiyonuna tekrar "elle" atanması.
Bu zorunluluk, ES5 kalıtımının veri bütünlüğünü koruma sorumluluğunu tamamen geliştiricinin dikkatine ve omuzlarına yüklediğinin en net kanıtıdır.
Söz Dizimsel Ağır Yükün (Overhead) SonuBu üçlü manuel operasyon ( Constructor Call, Prototip Linkleme ve Kimlik Onarımı ), ES5 kalıtımının ne kadar kırılgan ve zahmetli olduğunun teknik bir belgesidir.
Modern class yapısı, bu karmaşık "ritüeli" tek bir extends ve super() beyanının arkasına gizleyerek, geliştiricinin zihnini altyapı karmaşasından kurtarmıştır.
Bu evrim, JavaScript'in kurumsal ve büyük ölçekli yazılım mimarilerinde sürdürülebilir bir standart haline gelmesini sağlayan en kritik yapısal reformdur.
İçerik Tamamlandı
Bu konunun temel içeriği burada sona eriyor
Tebrikler! 🎉
Bu konuyu başarıyla tamamladınız! Sabırla ve azimle öğrendiğiniz her şey, programlama yolculuğunuzda önemli bir adımdır. Öğrendiklerinizi pekiştirmek için kod örneklerini tekrar gözden geçirebilir ve kendi projelerinizde uygulayabilirsiniz.
Öğrenme İpuçları
- Kod örneklerini kopyalayıp kendi editörünüzde deneyin
- Her örneği çalıştırın ve sonucu gözlemleyin
- Örnekleri değiştirip kendi versiyonlarınızı oluşturun
- Öğrendiklerinizi not alın ve tekrar edin
- Pratik yapmak için kendi mini projelerinizi oluşturun
Kod Örnekleri İstatistikleri
Bu sayfadaki tüm kod örneklerinin seviye dağılımı
HTML Seviye Dağılımı
CSS Seviye Dağılımı
JavaScript Seviye Dağılımı
class Araba {
constructor(marka) {
this.marka = marka;
}
}
Standart sınıf bildirimi, hoisting yok. En yaygın kullanılan
yöntem
const Motor = class {
constructor(guc) {
this.guc = guc;
}
};
Değişkene atanan sınıf ifadesi. İsimsiz sınıf oluşturma
class Kullanici {
constructor(ad, yas) {
this.ad = ad;
this.yas = yas;
}
}
Obje başlatma, otomatik çalışır. new ile çağrıldığında
tetiklenir
class Hesap {
bakiyeEkle(tutar) {
this.bakiye += tutar;
}
}
Obje örneğine ait metotlar. Her örnek için ayrı çalışır
class Bildirim {
gonderildi = false;
sayac = 0;
}
Açık alanlar, constructor'dan önce. ES2022 özelliği
class Personel {
#maas = 0;
getMaas() {
return this.#maas;
}
}
Özel alanlar, # ile tanımlanır. Sınıf dışından erişilemez
class Hesaplayici {
static kdvEkle(fiyat) {
return fiyat * 1.20;
}
}
Hesaplayici.kdvEkle(100);
Sınıf seviyesinde metotlar. Örnek oluşturmadan çağrılır
class Ayarlar {
static KDV_ORANI = 0.20;
static PI = 3.14159;
}
Sınıf seviyesinde sabitler. Tüm örnekler için ortak değer
class Hayvan {
constructor(ad) {
this.ad = ad;
}
}
class Kedi extends Hayvan {
constructor(ad, renk) {
super(ad);
this.renk = renk;
}
}
Alt sınıf oluşturma, prototip zinciri. Üst sınıfın özelliklerini
miras alır
class Kullanici {
constructor(ad) {
this.ad = ad;
}
}
class Admin extends Kullanici {
constructor(ad, seviye) {
super(ad); // Üst sınıf constructor
this.seviye = seviye;
}
}
Zorunlu çağrı, this'ten önce. Üst sınıf constructor'ını
çalıştırır
class TasarrufHesabi extends Hesap {
goster() {
const temel = super.goster();
return temel + ` | Faiz: %${this.oran}`;
}
}
Üst sınıf metotlarına erişim. Override edilmiş metotlarda
kullanılır
class Kedi extends Hayvan {
sesCikar() {
return "Miyav!"; // Üst sınıf metodunu ezer
}
}
Alt sınıfta metodun yeniden tanımı. Üst sınıf metodunu geçersiz
kılar
class Kullanici {
get tamAd() {
return `${this.ad} ${this.soyad}`;
}
}
const k = new Kullanici();
console.log(k.tamAd);
Özellik gibi erişilen metot. Parantez olmadan çağrılır
class Kullanici {
set eposta(deger) {
this._eposta = deger.toLowerCase();
}
}
k.eposta = "TEST@MAIL.COM";
Özellik gibi atanan metot. Değer atama sırasında çalışır
Öğrenme Yolu
JavaScript öğrenme yolculuğunuzda neredesiniz?
Bu bölüm, JavaScript öğrenme yolculuğunuzdaki ilerlemenizi görselleştirir. Aşağıda göreceğiniz adımlar, konular arasındaki mantıksal sıralamayı ve öğrenme akışını temsil eder. Tamamlanan konular mavi tonlarda gösterilir ve üzerinde bir onay işareti bulunur. Aktif konu, şu anda üzerinde çalıştığınız bölümdür ve parlak mavi renkle vurgulanır. Sonraki adımlar ise henüz tamamlanmamış konuları gösterir ve daha soluk tonlarda görüntülenir.
Her adım arasındaki oklar, öğrenme sırasını ve konular arasındaki bağlantıyı gösterir. Bu yapı, hangi konuları tamamladığınızı, hangi konuda olduğunuzu ve sıradaki adımlarınızı net bir şekilde görmenizi sağlar.
Class
ES6 Class yapısı ve kalıtım