TypeScript’te Sınıflar Nasıl Kullanılır: Kapsamlı Bir Rehber

TypeScript’te Sınıflar Nasıl Kullanılır: Kapsamlı Bir Rehber

Giriş

Modern yazılım geliştirme, karmaşık sistemlerin yönetilebilir ve sürdürülebilir bir şekilde inşa edilmesini gerektirir. Bu noktada Nesne Yönelimli Programlama (OOP) paradigması, kodun daha modüler, yeniden kullanılabilir ve anlaşılır olmasını sağlayan güçlü bir araç seti sunar. TypeScript, JavaScript’in bir üst kümesi (superset) olarak, OOP prensiplerini JavaScript ekosistemine tip güvenliği ve gelişmiş yapısal özelliklerle taşıyarak geliştiricilere benzersiz avantajlar sunar. ECMAScript 2015 (ES6) ile JavaScript’e sınıflar gelmiş olsa da, TypeScript bu sınıfları erişim belirleyiciler, soyut sınıflar, arayüz uygulamaları ve daha fazlası gibi ek özelliklerle zenginleştirir.

Bu makale, TypeScript’teki sınıfların temelden ileri seviyeye kadar nasıl kullanılacağını kapsamlı bir şekilde ele alacaktır. Sınıf tanımından miras almaya, erişim belirleyicilerden soyut sınıflara, arayüz uygulamalarından jenerik sınıflara kadar birçok konuyu detaylı örneklerle inceleyeceğiz. Amacımız, TypeScript’te sağlam, ölçeklenebilir ve bakımı kolay uygulamalar geliştirmek için sınıfları etkili bir şekilde kullanma konusunda size rehberlik etmektir.

Temel Sınıf Tanımı ve Kullanımı

TypeScript’te bir sınıf, class anahtar kelimesi kullanılarak tanımlanır. Bir sınıf, nesnelerin bir şablonu veya planı gibidir; özellikler (data) ve metotlar (davranışlar) içerir. Bir sınıftan oluşturulan her bir nesneye “örnek” (instance) denir.

Sınıf Özellikleri (Properties)

Sınıf özellikleri, sınıfın durumunu veya verilerini temsil eden değişkenlerdir. Bir sınıfın içinde doğrudan tanımlanırlar.

Sınıf Metotları (Methods)

Sınıf metotları, sınıfın davranışlarını veya işlevselliğini tanımlayan fonksiyonlardır.

Yapıcı Metot (Constructor)

Yapıcı metot, bir sınıftan yeni bir örnek oluşturulduğunda otomatik olarak çağrılan özel bir metottur. Örneğe başlangıç değerleri atamak veya gerekli kurulum işlemlerini yapmak için kullanılır. TypeScript’te bir sınıfın yalnızca bir yapıcı metodu olabilir. constructor anahtar kelimesi ile tanımlanır.

Bir sınıftan örnek oluşturmak için new anahtar kelimesi kullanılır.

İşte basit bir Kişi sınıfı örneği:

class Kisi {
    ad: string;
    soyad: string;
    yas: number;

    constructor(ad: string, soyad: string, yas: number) {
        this.ad = ad;
        this.soyad = soyad;
        this.yas = yas;
    }

    tamAdGetir(): string {
        return ${this.ad} ${this.soyad};
    }

    dogumYiliHesapla(): number {
        const currentYear = new Date().getFullYear();
        return currentYear - this.yas;
    }
}

// Sınıftan bir örnek oluşturma
const kisi1 = new Kisi("Ayşe", "Yılmaz", 30);
console.log(kisi1.tamAdGetir()); // Çıktı: Ayşe Yılmaz
console.log(kisi1.dogumYiliHesapla()); // Çıktı: 1994 (eğer yıl 2024 ise)

const kisi2 = new Kisi("Mehmet", "Demir", 25);
console.log(kisi2.tamAdGetir()); // Çıktı: Mehmet Demir

Yukarıdaki örnekte:
– ad, soyad ve yas sınıfın özellikleridir.
– constructor metodu, yeni bir Kisi nesnesi oluşturulduğunda bu özelliklere başlangıç değerleri atar.
– tamAdGetir ve dogumYiliHesapla metotları, Kisi nesnelerinin gerçekleştirebileceği eylemleri tanımlar.
– this anahtar kelimesi, sınıfın mevcut örneğine atıfta bulunur.

Erişim Belirleyiciler (Access Modifiers)

TypeScript, sınıf üyelerinin (özellikler ve metotlar) dışarıdan ne kadar erişilebilir olduğunu kontrol etmek için erişim belirleyiciler sunar. Bunlar public, private ve protected‘dır.

public

public varsayılan erişim belirleyicidir. public olarak işaretlenmiş bir üye, sınıfın içinden, sınıfın dışından ve miras alan sınıflardan erişilebilir.

class Araba {
    public marka: string;
    model: string; // Varsayılan olarak public

    constructor(marka: string, model: string) {
        this.marka = marka;
        this.model = model;
    }

    public bilgileriGoster(): string {
        return ${this.marka} ${this.model};
    }
}

const araba1 = new Araba("Toyota", "Corolla");
console.log(araba1.marka); // Erişilebilir
console.log(araba1.model); // Erişilebilir
console.log(araba1.bilgileriGoster()); // Erişilebilir

private

private olarak işaretlenmiş bir üye, yalnızca tanımlandığı sınıfın içinden erişilebilir. Sınıfın dışından veya miras alan sınıflardan erişilemez. Bu, bir sınıfın iç çalışma detaylarını gizlemek (encapsulation) için kullanışlıdır.

class BankaHesabi {
    private hesapNo: string;
    private bakiye: number;

    constructor(hesapNo: string, baslangicBakiye: number) {
        this.hesapNo = hesapNo;
        this.bakiye = baslangicBakiye;
    }

    yatir(miktar: number): void {
        if (miktar > 0) {
            this.bakiye += miktar;
            console.log(${miktar} TL yatırıldı. Yeni bakiye: ${this.bakiye} TL);
        } else {
            console.log("Geçersiz miktar.");
        }
    }

    cek(miktar: number): void {
        if (miktar > 0 && this.bakiye >= miktar) {
            this.bakiye -= miktar;
            console.log(${miktar} TL çekildi. Yeni bakiye: ${this.bakiye} TL);
        } else {
            console.log("Yetersiz bakiye veya geçersiz miktar.");
        }
    }

    getBakiye(): number {
        return this.bakiye;
    }
}

const hesap = new BankaHesabi("TR123456789", 1000);
// console.log(hesap.hesapNo); // Hata: 'hesapNo' private'tır ve sadece 'BankaHesabi' sınıfı içinde erişilebilir.
// console.log(hesap.bakiye);   // Hata: 'bakiye' private'tır.

hesap.yatir(500);
hesap.cek(200);
console.log(Güncel bakiye: ${hesap.getBakiye()} TL); // Bakiye, public bir metot aracılığıyla erişilebilir.

protected

protected olarak işaretlenmiş bir üye, tanımlandığı sınıfın içinden ve o sınıftan miras alan alt sınıfların içinden erişilebilir. Sınıfın dışından erişilemez.

class Calisan {
    protected id: number;
    public ad: string;

    constructor(id: number, ad: string) {
        this.id = id;
        this.ad = ad;
    }

    protected getCalisanBilgisi(): string {
        return ID: ${this.id}, Ad: ${this.ad};
    }
}

class Yonetici extends Calisan {
    departman: string;

    constructor(id: number, ad: string, departman: string) {
        super(id, ad); // Üst sınıfın constructor'ını çağırır
        this.departman = departman;
    }

    tamBilgileriGoster(): string {
        // protected id'ye ve protected getCalisanBilgisi() metoduna erişim mümkün
        return ${this.getCalisanBilgisi()}, Departman: ${this.departman};
    }
}

const yonetici = new Yonetici(101, "Elif Can", "İnsan Kaynakları");
console.log(yonetici.ad); // Public olduğu için erişilebilir
// console.log(yonetici.id); // Hata: 'id' protected'dır.
// console.log(yonetici.getCalisanBilgisi()); // Hata: 'getCalisanBilgisi' protected'dır.
console.log(yonetici.tamBilgileriGoster()); // Metot içinden protected üyelere erişim mümkün

Constructor Parametrelerinde Erişim Belirleyiciler

TypeScript, yapıcı metot parametrelerine erişim belirleyici ekleyerek sınıf özelliklerini otomatik olarak tanımlamanın ve başlatmanın kısa bir yolunu sunar.

class Urun {
    // markası public, fiyatı private olarak otomatik tanımlanır ve başlatılır
    constructor(public marka: string, private fiyat: number) {}

    getFiyat(): number {
        return this.fiyat;
    }
}

const telefon = new Urun("Samsung", 12000);
console.log(telefon.marka); // Samsung
// console.log(telefon.fiyat); // Hata: 'fiyat' private'tır.
console.log(telefon.getFiyat()); // 12000

Miras Alma (Inheritance)

Miras alma, bir sınıfın başka bir sınıfın özelliklerini ve metotlarını devralmasını sağlayan bir OOP prensibidir. Bu, kodun yeniden kullanılabilirliğini artırır ve hiyerarşik ilişkiler kurmaya yardımcı olur. TypeScript’te miras alma, extends anahtar kelimesi ile gerçekleştirilir. Miras alan sınıfa “alt sınıf” (subclass) veya “türetilmiş sınıf” (derived class), miras verilen sınıfa ise “üst sınıf” (superclass) veya “temel sınıf” (base class) denir.

class Hayvan {
    isim: string;

    constructor(isim: string) {
        this.isim = isim;
    }

    sesCikar(): string {
        return "Bilinmeyen bir ses çıkarıyor.";
    }
}

class Kedi extends Hayvan {
    cins: string;

    constructor(isim: string, cins: string) {
        super(isim); // Üst sınıfın constructor'ını çağırır
        this.cins = cins;
    }

    // Metot geçersiz kılma (Method Overriding)
    sesCikar(): string {
        return "Miyav!";
    }

    avlan(): string {
        return ${this.isim} (${this.cins}) avlanıyor.;
    }
}

class Kopek extends Hayvan {
    constructor(isim: string) {
        super(isim);
    }

    sesCikar(): string {
        return "Hav hav!";
    }
}

const kedi = new Kedi("Pamuk", "Tekir");
console.log(kedi.isim); // Pamuk (Hayvan sınıfından devralındı)
console.log(kedi.sesCikar()); // Miyav! (Kedi sınıfındaki geçersiz kılınmış metot)
console.log(kedi.avlan()); // Pamuk (Tekir) avlanıyor.

const kopek = new Kopek("Karabaş");
console.log(kopek.isim); // Karabaş
console.log(kopek.sesCikar()); // Hav hav!

const hayvan = new Hayvan("Leo");
console.log(hayvan.sesCikar()); // Bilinmeyen bir ses çıkarıyor.

super() anahtar kelimesi:
– Alt sınıfın yapıcı metodunda, üst sınıfın yapıcı metodunu çağırmak için kullanılır. Bu, üst sınıfın özelliklerinin doğru bir şekilde başlatılmasını sağlar. super() çağrısı, alt sınıfın yapıcı metodunun ilk işlemi olmalıdır.
– Alt sınıfta, üst sınıfın bir metodunu çağırmak için de super.metotAdi() şeklinde kullanılabilir.

Soyut Sınıflar ve Metotlar (Abstract Classes and Methods)

Soyut sınıflar, doğrudan örnekleri oluşturulamayan sınıflardır. Genellikle, belirli bir ortak davranışı tanımlayan ancak bu davranışın tam uygulamasını alt sınıflara bırakan bir temel sınıf sağlamak için kullanılırlar. Bir sınıfı soyut yapmak için abstract anahtar kelimesi kullanılır.

Soyut Metotlar

Soyut sınıflar, soyut metotlar içerebilir. Soyut metotlar, bir gövdeye sahip olmayan ve sadece imzasını (adını, parametrelerini ve dönüş tipini) tanımlayan metotlardır. Alt sınıflar, soyut sınıftan miras aldıklarında, tüm soyut metotları kendi uygulamalarıyla birlikte sağlamak zorundadır.

abstract class Sekil {
    constructor(public renk: string) {}

    abstract alanHesapla(): number; // Soyut metot, alt sınıflar uygulamak zorunda
    abstract cevreHesapla(): number; // Soyut metot

    bilgiGoster(): string {
        return Bu bir ${this.renk} renkteki şekildir.;
    }
}

class Kare extends Sekil {
    kenarUzunlugu: number;

    constructor(renk: string, kenarUzunlugu: number) {
        super(renk);
        this.kenarUzunlugu = kenarUzunlugu;
    }

    alanHesapla(): number {
        return this.kenarUzunlugu * this.kenarUzunlugu;
    }

    cevreHesapla(): number {
        return 4 * this.kenarUzunlugu;
    }
}

class Daire extends Sekil {
    yaricap: number;

    constructor(renk: string, yaricap: number) {
        super(renk);
        this.yaricap = yaricap;
    }

    alanHesapla(): number {
        return Math.PI  this.yaricap  this.yaricap;
    }

    cevreHesapla(): number {
        return 2  Math.PI  this.yaricap;
    }
}

// const sekil = new Sekil("Kırmızı"); // Hata: Soyut sınıflar doğrudan örneklenemez.

const kare = new Kare("Mavi", 5);
console.log(kare.bilgiGoster()); // Bu bir Mavi renkteki şekildir.
console.log(Kare Alan: ${kare.alanHesapla()}); // Kare Alan: 25
console.log(Kare Çevre: ${kare.cevreHesapla()}); // Kare Çevre: 20

const daire = new Daire("Yeşil", 3);
console.log(daire.bilgiGoster()); // Bu bir Yeşil renkteki şekildir.
console.log(Daire Alan: ${daire.alanHesapla()}); // Daire Alan: 28.27...
console.log(Daire Çevre: ${daire.cevreHesapla()}); // Daire Çevre: 18.84...

Soyut sınıflar, farklı alt sınıfların ortak bir arayüzü paylaşmasını sağlarken, aynı zamanda bazı varsayılan uygulamalar veya ortak özellikler sunarak kod tekrarını azaltır.

Arayüzler (Interfaces) ve Sınıflar

TypeScript’te arayüzler, bir nesnenin veya sınıfın sahip olması gereken özellik ve metot imzalarını tanımlayan sözleşmelerdir. Sınıflar, implements anahtar kelimesini kullanarak bir veya daha fazla arayüzü uygulayabilir. Bir sınıf bir arayüzü uyguladığında, arayüzde tanımlanan tüm özellikleri ve metotları kendi içinde sağlamak zorundadır.

interface Yazdirilabilir {
    yazdir(): void;
}

interface Kaydedilebilir {
    kaydet(): void;
}

class Rapor implements Yazdirilabilir, Kaydedilebilir {
    baslik: string;
    icerik: string;

    constructor(baslik: string, icerik: string) {
        this.baslik = baslik;
        this.icerik = icerik;
    }

    yazdir(): void {
        console.log(Rapor Yazdırılıyor: ${this.baslik}\n${this.icerik});
    }

    kaydet(): void {
        console.log(Rapor Kaydediliyor: ${this.baslik});
        // Veritabanına kaydetme veya dosya yazma mantığı burada olabilir
    }
}

class Belge implements Yazdirilabilir {
    ad: string;
    sayfaSayisi: number;

    constructor(ad: string, sayfaSayisi: number) {
        this.ad = ad;
        this.sayfaSayisi = sayfaSayisi;
    }

    yazdir(): void {
        console.log(Belge Yazdırılıyor: ${this.ad}, Sayfa Sayısı: ${this.sayfaSayisi});
    }
}

const rapor = new Rapor("Yıllık Satış Raporu", "Bu rapor, geçen yılın satış verilerini özetlemektedir...");
rapor.yazdir();
rapor.kaydet();

const belge = new Belge("Kullanım Kılavuzu", 50);
belge.yazdir();

Arayüzler, polimorfizm için çok önemlidir ve kodunuzun daha esnek ve test edilebilir olmasını sağlar. Bir fonksiyonun, belirli bir arayüzü uygulayan herhangi bir sınıfın örneğini kabul etmesini sağlayabilirsiniz.

Statik Üyeler (Static Members)

Statik üyeler (özellikler ve metotlar), bir sınıfın örneklerine değil, doğrudan sınıfın kendisine aittir. Bunlara sınıf adı üzerinden erişilir, bir sınıf örneği oluşturmaya gerek yoktur. Statik üyeler genellikle yardımcı fonksiyonlar, sabitler veya bir sınıfın tüm örnekleri arasında paylaşılan veriler için kullanılır.

class Matematik {
    static PI: number = 3.14159; // Statik özellik

    static topla(a: number, b: number): number { // Statik metot
        return a + b;
    }

    static carp(a: number, b: number): number {
        return a * b;
    }
}

console.log(Matematik.PI); // 3.14159
console.log(Matematik.topla(5, 3)); // 8
console.log(Matematik.carp(4, 2)); // 8

// Statik olmayan bir özellik veya metoda örnek üzerinden erişilebilir
// const mat = new Matematik(); // Hata: Matematik sınıfı statik üyeler içerdiği için örneklenmesine gerek yok.

Statik metotlar, this anahtar kelimesini kullanarak sınıfın statik özelliklerine veya diğer statik metotlarına erişebilir, ancak sınıfın örnek özelliklerine veya metotlarına erişemezler.

Salt Okunur Özellikler (Readonly Properties)

readonly anahtar kelimesi, bir sınıf özelliğinin yalnızca tanımlandığı yerde veya yapıcı metot içinde atanabileceğini ve daha sonra değiştirilemeyeceğini belirtir. Bu, değişmez (immutable) veri özelliklerini tanımlamak için kullanışlıdır.

class Ayar {
    readonly id: string;
    public ayarAdi: string;
    private readonly olusturmaTarihi: Date;

    constructor(id: string, ayarAdi: string) {
        this.id = id; // Yapıcı metotta atanabilir
        this.ayarAdi = ayarAdi;
        this.olusturmaTarihi = new Date(); // Yapıcı metotta atanabilir
    }

    // setId(newId: string): void {
    //     this.id = newId; // Hata: 'id' salt okunur bir özelliktir.
    // }

    getOlusturmaTarihi(): Date {
        return this.olusturmaTarihi;
    }
}

const genelAyar = new Ayar("GENEL_AYAR_1", "Uygulama Teması");
console.log(genelAyar.id); // GENEL_AYAR_1
// genelAyar.id = "YENI_ID"; // Hata: 'id' salt okunur bir özelliktir.
genelAyar.ayarAdi = "Karanlık Tema"; // ayarAdi public ve readonly değil, değiştirilebilir
console.log(genelAyar.ayarAdi); // Karanlık Tema
console.log(genelAyar.getOlusturmaTarihi()); // Tarih objesi

Getter ve Setter Metotları (Erişimciler)

Getter (get) ve Setter (set) metotları, bir sınıfın özelliklerine erişimi ve atamayı kontrol etmenizi sağlar. Bu, veri doğrulama, yan etkileri yönetme veya dahili bir değeri dışarıya farklı bir formatta sunma gibi durumlar için kullanışlıdır.

class Kullanici {
    private _yas: number;
    public ad: string;

    constructor(ad: string, yas: number) {
        this.ad = ad;
        this.yas = yas; // Setter çağrılır
    }

    // Getter: _yas özelliğine kontrollü erişim sağlar
    get yas(): number {
        return this._yas;
    }

    // Setter: _yas özelliğine kontrollü atama yapar
    set yas(yeniYas: number) {
        if (yeniYas < 0 || yeniYas > 120) {
            console.error("Geçersiz yaş değeri!");
            return;
        }
        this._yas = yeniYas;
    }
}

const kullanici = new Kullanici("Zeynep", 30);
console.log(kullanici.ad); // Zeynep
console.log(kullanici.yas); // 30 (getter çağrıldı)

kullanici.yas = 25; // Setter çağrıldı
console.log(kullanici.yas); // 25

kullanici.yas = 150; // Setter çağrıldı, hata mesajı basılır
console.log(kullanici.yas); // Hala 25, çünkü atama geçersizdi

Getter ve setter’lar, özelliklere doğrudan erişim yerine bir soyutlama katmanı sağlar, bu da sınıfın iç yapısını değiştirmeden dışarıya sunulan arayüzü korumanıza olanak tanır.

Jenerik Sınıflar (Generic Classes)

Jenerikler, bir sınıfın veya fonksiyonun birden fazla tipte veriyle çalışabilmesini sağlarken, aynı zamanda tip güvenliğini korumasına olanak tanır. Jenerik sınıflar, farklı veri tipleri üzerinde çalışan ancak aynı mantığı uygulayan sınıflar oluşturmak için kullanışlıdır.

class Depo {
    private ogeler: T[] = [];

    ekle(oge: T): void {
        this.ogeler.push(oge);
    }

    getOge(index: number): T | undefined {
        return this.ogeler[index];
    }

    getTumOgeler(): T[] {
        return this.ogeler;
    }
}

// Sayı depolayan bir depo
const sayiDeposu = new Depo();
sayiDeposu.ekle(10);
sayiDeposu.ekle(20);
// sayiDeposu.ekle("Merhaba"); // Hata: 'string' tipi 'number' tipine atanamaz.
console.log(sayiDeposu.getTumOgeler()); // [10, 20]

// String depolayan bir depo
const stringDeposu = new Depo();
stringDeposu.ekle("Elma");
stringDeposu.ekle("Armut");
console.log(stringDeposu.getTumOgeler()); // ["Elma", "Armut"]

// Özel bir obje depolayan depo
interface Kitap {
    baslik: string;
    yazar: string;
}

const kitapDeposu = new Depo();
kitapDeposu.ekle({ baslik: "Savaş ve Barış", yazar: "Lev Tolstoy" });
kitapDeposu.ekle({ baslik: "Suç ve Ceza", yazar: "Fyodor Dostoyevski" });
console.log(kitapDeposu.getOge(0)?.baslik); // Savaş ve Barış

Jenerikler, kod tekrarını azaltır ve daha esnek, yeniden kullanılabilir bileşenler oluşturmanıza yardımcı olur.

Sınıflarda this Anahtar Kelimesi

this anahtar kelimesi, JavaScript ve dolayısıyla TypeScript’te sıklıkla kafa karışıklığına neden olan bir konudur. Bir sınıf metodunun içinde this, o metodu çağıran sınıf örneğine atıfta bulunur. Ancak, metot bir olay dinleyicisi olarak veya başka bir bağlamda çağrıldığında this‘in değeri değişebilir.

class Buton {
    etiket: string;

    constructor(etiket: string) {
        this.etiket = etiket;
    }

    tikla(): void {
        console.log(${this.etiket} tıklandı.);
    }

    // Metodu farklı bir bağlamda çağırmak için
    addEventListener(event: string, handler: Function): void {
        // Normalde DOM olay dinleyicisi olurdu, burada simüle ediyoruz
        console.log(Olay dinleyici eklendi: ${event});
        // handler(); // Eğer böyle çağrılırsa, 'this' buton nesnesi olmaz
    }
}

const myButton = new Buton("Gönder");
myButton.tikla(); // Çıktı: Gönder tıklandı. (this = myButton)

// Problem: Eğer metodu başka bir fonksiyona callback olarak verirsek
const tiklaFonksiyonu = myButton.tikla;
// tiklaFonksiyonu(); // Hata veya undefined: 'this' pencere objesi veya undefined olur.

// Çözüm 1: Metodu bağlamak (bind)
const bagliTiklaFonksiyonu = myButton.tikla.bind(myButton);
bagliTiklaFonksiyonu(); // Çıktı: Gönder tıklandı.

// Çözüm 2: Arrow fonksiyonları kullanmak
class ButonArrow {
    etiket: string;

    constructor(etiket: string) {
        this.etiket = etiket;
    }

    // Arrow fonksiyonları 'this' bağlamını tanımlandıkları yere sabitler
    tikla = (): void => {
        console.log(${this.etiket} tıklandı (Arrow).);
    }
}

const myButtonArrow = new ButonArrow("Kaydet");
const tiklaArrowFonksiyonu = myButtonArrow.tikla;
tiklaArrowFonksiyonu(); // Çıktı: Kaydet tıklandı (Arrow). (this = myButtonArrow)

Arrow fonksiyonları, this‘in lexical scope’unu (tanımlandığı yerin bağlamını) koruduğu için, sınıf metotlarında this bağlamı sorunlarını çözmek için sıkça tercih edilir.

Sınıfların Diğer TypeScript Özellikleriyle Etkileşimi

TypeScript sınıfları, dilin diğer güçlü özellikleriyle birleştiğinde daha da etkili hale gelir:

* Dekoratörler (Decorators): Deneyimsel bir özellik olmasına rağmen, dekoratörler sınıfları, metotları, özellikleri veya parametreleri değiştirmek için kullanılabilir. Genellikle Angular gibi framework’lerde veya bağımlılık enjeksiyonu gibi kalıplarda yaygın olarak kullanılırlar. Örneğin, bir metodu otomatik olarak loglamak veya bir özelliği belirli bir validasyon kuralına tabi tutmak için dekoratörler kullanılabilir.
* Mixins: TypeScript, JavaScript’in prototip tabanlı doğasından faydalanarak sınıflara birden fazla kaynaktan işlevsellik “karıştırma” (mixin) yeteneği sunar. Bu, çoklu kalıtımın bazı faydalarını, JavaScript’in tek kalıtım modelini bozmadan elde etmenizi sağlar.

Bu konuların her biri ayrı bir makale konusu olabilecek kadar geniş kapsamlıdır, ancak TypeScript sınıflarının ekosistemde nasıl daha da güçlendirilebileceğini gösterirler.

Neden TypeScript Sınıflarını Kullanmalıyız? (Avantajlar)

TypeScript sınıflarını kullanmak, birçok avantaj sunar:

1. Tip Güvenliği: Sınıf özellikleri ve metot parametreleri için tip tanımları, derleme zamanında hataları yakalamaya yardımcı olur, bu da çalışma zamanı hatalarını azaltır.
2. Kodun Okunabilirliği ve Bakımı: Sınıflar, kodunuzu mantıksal birimlere ayırarak daha düzenli ve okunabilir hale getirir. OOP prensipleri sayesinde kodun bakımı ve genişletilmesi kolaylaşır.
3. Büyük Ölçekli Uygulamalar İçin Yapı: Karmaşık ve büyük ölçekli uygulamalarda, sınıflar kod tabanını organize etmek ve yönetmek için sağlam bir yapı sunar.
4. OOP Prensiplerini Uygulama Kolaylığı: Kapsülleme (encapsulation), miras alma (inheritance) ve polimorfizm (polymorphism) gibi OOP prensipleri, TypeScript sınıfları aracılığıyla doğal bir şekilde uygulanabilir.
5. Refactoring Kolaylığı: Tip bilgisi sayesinde IDE’ler, sınıflar üzerinde daha akıllı refactoring araçları sunabilir, bu da kodu güvenli bir şekilde yeniden yapılandırmayı kolaylaştırır.
6. Geliştirici Deneyimi: Otomatik tamamlama, tip kontrolü ve anında hata tespiti gibi özellikler, geliştiricilerin daha hızlı ve hatasız kod yazmasına yardımcı olur.

Sonuç

TypeScript’teki sınıflar, modern JavaScript uygulamaları için güçlü ve esnek bir yapı taşıdır. JavaScript’in ES6 sınıflarına tip güvenliği, erişim belirleyiciler, soyut sınıflar ve arayüz uygulamaları gibi önemli özellikler ekleyerek, TypeScript geliştiricilere daha sağlam, bakımı kolay ve ölçeklenebilir uygulamalar oluşturma yeteneği kazandırır.

Bu makalede ele aldığımız temel sınıf tanımlarından miras almaya, erişim belirleyicilerden soyut sınıflara, jeneriklerden getter/setter metotlarına kadar birçok konu, TypeScript sınıflarının zenginliğini ve gücünü göstermektedir. Bu özellikleri doğru bir şekilde anlamak ve uygulamak, özellikle büyük ve karmaşık projelerde kod kalitesini önemli ölçüde artıracaktır. TypeScript sınıflarını etkili bir şekilde kullanarak, nesne yönelimli tasarım prensiplerini uygulamaya ve daha sürdürülebilir yazılım çözümleri geliştirmeye bir adım daha yaklaşmış olacaksınız.