Pratikte hangi tasarım desenlerini kullandınız…

Pratikte, uyguladığım tasarım kalıpları şunlardır:

Fabrika Yöntemi (Factory Method): Belirli bir sınıfı belirtmeden farklı türde nesneler oluşturmak için. Farklı veri kaynakları veya yapılandırmalarla çalışırken kullanışlıdır.

// Fabrika yönteminin kullanımı örneği
class DataReader {
  read() {
    throw new Error("Yöntem uygulanmadı");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Dosyadan veri okunuyor...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Ağdan veri okunuyor...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Bilinmeyen okuyucu tipi");
    }
  }
}

const factory = new DataReaderFactory();
const fileReader = factory.createReader("file");
fileReader.read();

Singleton (Tekil): Sadece bir örneğin varlığını garanti altına almak ve ona küresel erişim noktası sağlamak için. Sıkça yapılandırma yöneticileri veya veritabanı bağlantıları için kullanılır.

// Tekil örneğin kullanımı
class ConfigManager {
  constructor() {
    if (ConfigManager.instance) {
      return ConfigManager.instance;
    }
    this.config = {};
    ConfigManager.instance = this;
  }

  setConfig(key, value) {
    this.config[key] = value;
  }

  getConfig(key) {
    return this.config[key];
  }
}

const instance1 = new ConfigManager();
const instance2 = new ConfigManager();

console.log(instance1 === instance2); // true

Gözlemci (Observer): "birden çok-ile" ilişkisini uygulamak için, burada bir nesnenin (yayıncı) durumu değiştiğinde, bağlı tüm nesneler (aboneler) otomatik olarak bilgilendirilir. Bildirim sistemleri, reaktif arayüzlerde kullanılır.

// Gözlemci kullanım örneği
class Observable {
  constructor() {
    this.observers = [];
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }

  notify(data) {
    this.observers.forEach(observer => observer.update(data));
  }
}

class Observer {
  update(data) {
    console.log("Gelen güncelleme:", data);
  }
}

const observable = new Observable();
const observer1 = new Observer();
const observer2 = new Observer();

observable.subscribe(observer1);
observable.subscribe(observer2);

observable.notify("Yeni veri mevcut!");

Strateji (Strategy): Bir algoritma ailesini tanımlamak, her birini kapsüllemek ve birbirleriyle değiştirilebilir hale getirmek için. Bu, algoritmanın bağımsız olarak değişmesine olanak tanır. Veri işleme veya işlemleri gerçekleştirme gibi çeşitli durumlar için kullanılır.

// Stratejinin kullanımı örneği
class PaymentStrategy {
  pay(amount) {
    throw new Error("Uygulanmadı");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`${amount} ödemesi kredi kartı ile yapılıyor`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`${amount} ödemesi PayPal ile yapılıyor`);
  }
}

class PaymentContext {
  setStrategy(strategy) {
    this.strategy = strategy;
  }

  executePayment(amount) {
    this.strategy.pay(amount);
  }
}

const context = new PaymentContext();
context.setStrategy(new CreditCardPayment());
context.executePayment(100);

context.setStrategy(new PayPalPayment());
context.executePayment(50);

Dekoratör (Decorator): Bir nesneye yeni işlevsellikleri dinamik olarak eklemek için, yapısını değiştirmeden. Mevcut nesneyi sarmalar ve aynı arayüzü sağlar, ancak ek işlevsellik ile. Günlük kaydı, doğrulama, önbellekleme gibi işlemler için kullanılır.

// Dekoratör kullanım örneği
class Component {
  operation() {
    return "Temel Bileşen";
  }
}

class Decorator {
  constructor(component) {
    this.component = component;
  }

  operation() {
    return this.component.operation();
  }
}

class ConcreteDecoratorA extends Decorator {
  operation() {
    return `ConcreteDecoratorA(${super.operation()})`;
  }
}

class ConcreteDecoratorB extends Decorator {
  operation() {
    return `ConcreteDecoratorB(${super.operation()})`;
  }
}

const simple = new Component();
console.log(simple.operation());

const decoratorA = new ConcreteDecoratorA(simple);
console.log(decoratorA.operation());

const decoratorB = new ConcreteDecoratorB(decoratorA);
console.log(decoratorB.operation());

Modül (Module): Node.js'in yerleşik modül sistemi (CommonJS, ES Modules) olmasına rağmen, JavaScript'te Module pattern (yerel modüller) kullanılırdı, bu da özel üyeler ve genel arayüzler oluşturmak için kullanılırdı. Kapsüllenmiş kod yapısı oluşturmak için temel oluşturur.

Bu kalıplar, daha yapılandırılmış, ölçeklenebilir ve sürdürülebilir kodlar yazmama yardımcı oldu.

Pratikte hangi tasarım desenlerini kullandınız?