Yazılım geliştirme süreçlerinde, mevcut bir nesnenin veya fonksiyonun davranışını, o nesneyi doğrudan değiştirmeden genişletmek veya iyileştirmek yaygın bir ihtiyaçtır. Belki bir fonksiyona loglama özelliği eklemek, bir methoda önbellekleme katmanı getirmek veya bir yetkilendirme kontrolü yapmak istiyoruzdur, ancak bunu yaparken orijinal kodu kirletmek veya karmaşık miras hiyerarşileri oluşturmak istemeyiz. İşte bu noktada Decorator deseni devreye giriyor.

Benim tecrübelerimde, özellikle modüler ve esnek JavaScript ve Node.js uygulamaları geliştirirken, Decorator deseninin ne kadar güçlü ve temiz bir çözüm sunduğunu defalarca gördüm. Bu desen, kodu daha okunabilir, bakımı kolay ve ölçeklenebilir hale getirirken, aynı zamanda bileşenlerin yeniden kullanılabilirliğini de artırır. Bu yazıda, JavaScript ve Node.js ekosisteminde Decorator desenini nasıl uygulayabileceğinizi, farklı kullanım senaryolarını ve projenize katacağı avantajları detaylı örneklerle inceleyeceğiz.

Decorator Deseni Nedir ve Neden Kullanılır?

Decorator deseni (Sarmalayıcı deseni olarak da bilinir), bir nesneye, onu değiştirmeden dinamik olarak yeni sorumluluklar eklemenizi sağlayan yapısal bir tasarım desenidir. Mevcut bir nesnenin davranışını artırmak için bir alternatif sunar. Kalıtımdan farklı olarak, Decorator deseni esnekliği artırır, çünkü davranışlar çalışma zamanında eklenebilir veya kaldırılabilir. Hatırlarsanız, JavaScript ve Node.js'te Tasarım Desenleri yazımda da tasarım desenlerinin modülerlik ve esneklik konusundaki önemine değinmiştim.

Kalıtımın Sınırlılıkları ve Decorator'ın Avantajları

Yeni işlevsellik eklemek için genellikle kalıtım (inheritance) yolu kullanılır. Ancak kalıtım, özellikle çok sayıda işlevsellik kombinasyonu olduğunda "sınıf patlamasına" (class explosion) yol açabilir. Örneğin, bir kahve sipariş sistemi düşünün; sadece sade kahve, sütlü kahve, çikolatalı kahve, karamelli kahve, sütlü-çikolatalı kahve... her kombinasyon için ayrı bir sınıf oluşturmak zorunda kalırsınız. Decorator deseni ise bu sorunu, bileşenleri dinamik olarak sarmalayarak çözer.

Esneklik: Çalışma zamanında nesnelere yeni davranışlar ekleyip çıkarabilme.
Kod Tekrarını Azaltma: Ortak davranışları farklı dekoratörlerde izole etme.
Sorumlulukların Ayrılması: Her bir dekoratör, tek bir sorumluluğu yerine getirir, bu da kodun okunabilirliğini ve bakımını artırır.
Açık/Kapalı Prensibi (Open/Closed Principle): Mevcut kodu değiştirmeden yeni özellikler eklemeye olanak tanır.

Diagram illustrating the Decorator pattern, showing how it dynamically adds functionality to objects, contrasting with the limitations of traditional inheritance structures.

JavaScript ve Node.js'te Decorator Deseni Uygulamaları

JavaScript'in dinamik yapısı, Decorator desenini fonksiyonlara veya nesnelere kolayca uygulayabilmemiz için geniş imkanlar sunar. Hem fonksiyonel programlama tarzında fonksiyon dekoratörleri hem de sınıf tabanlı yaklaşımlarda sınıf ve method dekoratörleri olarak karşımıza çıkabilir.

1. Fonksiyon Dekorasyonları

Bir fonksiyona ek davranışlar kazandırmak için başka bir fonksiyonu kullanabiliriz. Bu, JavaScript'te oldukça yaygın bir desendir.

Örnek: Loglama Dekorasyonu

Bir fonksiyonun çalışma zamanını ve giriş/çıkış değerlerini loglamak istediğimizi varsayalım. Orijinal fonksiyonu değiştirmeden bunu bir dekoratör ile yapabiliriz:

function logPerformance(func) {
  return function(...args) {
    const start = Date.now();
    console.log(`Fonksiyon '${func.name}' çalıştırılıyor... Argümanlar: ${JSON.stringify(args)}`);
    const result = func.apply(this, args);
    const end = Date.now();
    console.log(`Fonksiyon '${func.name}' tamamlandı. Sonuç: ${JSON.stringify(result)}. Süre: ${end - start}ms`);
    return result;
  };
}

function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

const loggedAdd = logPerformance(add);
const loggedMultiply = logPerformance(multiply);

console.log(loggedAdd(5, 3));
console.log(loggedMultiply(4, 6));

Bu örnekte logPerformance, add ve multiply fonksiyonlarını sarmalayarak onlara loglama yeteneği ekledi. Orijinal fonksiyonlar aynı kaldı.

Örnek: Önbellekleme Dekorasyonu

Sıkça çağrılan ve aynı argümanlarla her zaman aynı sonucu veren fonksiyonlar için önbellekleme (caching) çok faydalıdır. Bu da bir dekoratör ile kolayca yapılabilir:

function memoize(func) {
  const cache = {};
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache[key]) {
      console.log(`Önbellekten döndü: ${key}`);
      return cache[key];
    }
    console.log(`Hesaplama yapıldı: ${key}`);
    const result = func.apply(this, args);
    cache[key] = result;
    return result;
  };
}

function factorial(n) {
  if (n === 0 || n === 1) return 1;
  return n * factorial(n - 1);
}

const memoizedFactorial = memoize(factorial);

console.log(memoizedFactorial(5)); // Hesaplama yapıldı
console.log(memoizedFactorial(5)); // Önbellekten döndü
console.log(memoizedFactorial(6)); // Hesaplama yapıldı

2. Sınıf ve Method Dekorasyonları (ES Dekorasyonları)

JavaScript'te sınıflar ve onların methodları üzerinde dekoratörler kullanmak da mümkündür. Bu genellikle bir ECMAScript proposal'ı olan dekoratör sözdizimi ile yapılır ve TypeScript'te yaygın olarak kullanılır. Şu anda bir aşama 3 önerisidir, yani Babel gibi dönüştürücülerle kullanılabilir.

Örnek: Method Dekorasyonu ile Yetkilendirme

Bir kullanıcı servisinde, sadece belirli rollere sahip kullanıcıların erişebileceği methodları işaretlemek için bir dekoratör kullanabiliriz. Bu, güvenli kimlik doğrulama ve yetkilendirme konularında işimize yarayabilir.

function authorize(role) {
  return function(target, key, descriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function(...args) {
      // Varsayımsal olarak 'this.currentUser' üzerinden rol kontrolü yapılıyor.
      // Gerçek bir uygulamada, JWT'den veya oturumdan gelen kullanıcı bilgisi kullanılır.
      if (this.currentUser && this.currentUser.role === role) {
        console.log(`Kullanıcı ${this.currentUser.username} yetkili. İşlem başlatılıyor.`);
        return originalMethod.apply(this, args);
      } else {
        console.error(`Kullanıcı ${this.currentUser ? this.currentUser.username : 'Bilinmiyor'} yetkisiz! Gerekli rol: ${role}`);
        throw new Error('Yetkisiz erişim!');
      }
    };
    return descriptor;
  };
}

class UserService {
  constructor(currentUser) {
    this.currentUser = currentUser;
  }

  @authorize('admin')
  deleteUser(userId) {
    console.log(`${userId} ID'li kullanıcı silindi.`);
    return true;
  }

  @authorize('user')
  getUserProfile(userId) {
    console.log(`${userId} ID'li kullanıcı profili getirildi.`);
    return { id: userId, username: 'testuser' };
  }
}

const adminUser = { username: 'admin', role: 'admin' };
const regularUser = { username: 'john_doe', role: 'user' };

const adminService = new UserService(adminUser);
const userService = new UserService(regularUser);

adminService.deleteUser('123'); // Admin yetkili, silme başarılı.
userService.getUserProfile('456'); // User yetkili, profil getirildi.

try {
  userService.deleteUser('789'); // User yetkisiz, hata fırlatılır.
} catch (error) {
  console.log(error.message);
}

Visual example of ES Class and Method Decorators in JavaScript/TypeScript, showing their application.

3. Node.js Middleware'leri ve Decorator Deseni

Express.js gibi popüler Node.js framework'lerinde middleware'ler, Decorator deseninin pratik bir uygulamasını temsil eder. Bir isteğin işlenmesinden önce veya sonra ek işlevsellik (kimlik doğrulama, loglama, hata yönetimi) eklemek için kullanılırlar. Her bir middleware fonksiyonu, bir isteği sarmalayarak ona yeni bir davranış ekler.

const express = require('express');
const app = express();

// Loglama Middleware'i (Decorator gibi davranır)
function requestLogger(req, res, next) {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next(); // Zincirdeki bir sonraki middleware'e veya route'a geç
}

// Kimlik Doğrulama Middleware'i
function authenticate(req, res, next) {
  const token = req.headers.authorization;
  if (token === 'VALID_TOKEN') {
    req.user = { id: 1, role: 'admin' }; // Kullanıcı bilgisini request objesine ekle
    next();
  } else {
    res.status(401).send('Yetkisiz');
  }
}

app.use(requestLogger); // Tüm rotaları sarmala

app.get('/public', (req, res) => {
  res.send('Herkese açık içerik');
});

app.get('/admin', authenticate, (req, res) => {
  // Buraya sadece kimliği doğrulanmış kullanıcılar ulaşır
  res.send(`Admin içeriği. Kullanıcı: ${req.user.role}`);
});

// Hata yönetimi middleware'i de bir tür dekoratördür.
app.use((err, req, res, next) => {
  console.error('Bir hata oluştu:', err.stack);
  res.status(500).send('Sunucuda bir hata oluştu!');
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Sunucu ${PORT} portunda çalışıyor.`));

Bu örnekte requestLogger ve authenticate middleware'leri, gelen HTTP isteklerini sarmalayarak onlara loglama ve kimlik doğrulama davranışları ekler. Bu, Decorator deseninin bir başka pratik yansımasıdır. Özellikle Node.js ve Express.js'te Güçlü Hata Yönetimi konusunda middleware kullanımı kritik bir rol oynar.

Decorator Deseninin Kullanım Alanları ve Faydaları

Decorator deseninin esnekliği, onu birçok farklı senaryoda değerli kılar:

Loglama ve İzleme: Fonksiyonların veya methodların çalışma zamanı, argümanları ve dönüş değerlerini loglamak.
Önbellekleme (Caching): Fonksiyon çağrılarının sonuçlarını önbelleğe alarak performansı artırmak.
Yetkilendirme ve Kimlik Doğrulama: Belirli fonksiyonlara veya rotalara erişimi kısıtlamak.
Girdi Validasyonu: Fonksiyon parametrelerini veya HTTP istek gövdelerini doğrulamak.
Hata Yönetimi: Fonksiyon çağrıları etrafında hata yakalama ve işleme mantığı eklemek.
Rate Limiting: Belirli bir fonksiyonun çağrı sıklığını sınırlamak.
Veri Dönüşümü: Bir fonksiyonun çıktısını belirli bir formata dönüştürmek.

Sonuç

Decorator deseni, JavaScript ve Node.js uygulamalarınızda kod kalitesini, esnekliği ve bakımı önemli ölçüde artıran güçlü bir yapısal desendir. Mevcut nesneleri ve fonksiyonları değiştirmeden onlara dinamik olarak yeni davranışlar ekleme yeteneği sayesinde, daha modüler, yeniden kullanılabilir ve test edilebilir kod yazmanıza olanak tanır.

İster fonksiyonel dekoratörler, ister gelecekte standartlaşacak sınıf ve method dekoratörleri aracılığıyla olsun, bu desen, projenizin büyümesiyle ortaya çıkabilecek karmaşıklığı yönetmenize yardımcı olacaktır. Unutmayın, her tasarım deseni gibi Decorator da doğru sorunu çözmek için doğru yerde kullanılmalıdır. Aşırı kullanımdan kaçınmak, karmaşıklığı artırmak yerine azaltmanın anahtarıdır.

Eğer aklınıza takılan sorular olursa veya bu konularda daha derinlemesine bilgi almak isterseniz, bana ismailyagci371@gmail.com adresinden veya sosyal medya kanallarından (İsmail YAĞCI) ulaşabilirsiniz. Sağlıklı ve başarılı kodlamalar dilerim!

JavaScript ve Node.js'te Decorator Deseni: Fonksiyonellikleri Dinamik Olarak Geliştirin