JavaScript Tasarım Kalıpları: Modern Geliştiriciler için Kapsamlı Bir Uygulama Rehberi

Giriş: Sağlam Kodun Temel Planı

Yazılım geliştirmenin dinamik dünyasında, sadece çalışan kod yazmak ilk adımdır. Asıl zorluk ve profesyonel bir geliştiricinin işareti, ölçeklenebilir, bakımı yapılabilir ve başkalarının anlaması ve üzerinde işbirliği yapması kolay bir kod oluşturmaktır. İşte bu noktada tasarım kalıpları devreye girer. Bunlar belirli algoritmalar veya kütüphaneler değil, yazılım mimarisinde tekrar eden sorunları çözmek için kullanılan üst düzey, dilden bağımsız planlardır.

JavaScript geliştiricileri için tasarım kalıplarını anlamak ve uygulamak her zamankinden daha kritiktir. Karmaşık ön-yüz (front-end) framework'lerinden Node.js üzerindeki güçlü arka-yüz (backend) servislerine kadar uygulamaların karmaşıklığı arttıkça, sağlam bir mimari temel pazarlık konusu dahi olamaz. Tasarım kalıpları, gevşek bağlılığı (loose coupling), sorumlulukların ayrılmasını (separation of concerns) ve kodun yeniden kullanılabilirliğini teşvik eden, savaşta test edilmiş çözümler sunarak bu temeli sağlar.

Bu kapsamlı rehber, size tasarım kalıplarının üç temel kategorisini net açıklamalar ve pratik, modern JavaScript (ES6+) uygulama örnekleriyle anlatacaktır. Amacımız, belirli bir sorun için hangi kalıbı kullanacağınızı ve projelerinizde nasıl etkili bir şekilde uygulayacağınızı belirleme bilgisiyle sizi donatmaktır.

Tasarım Kalıplarının Üç Temel Taşı

Tasarım kalıpları genellikle, her biri farklı bir mimari zorluk setini ele alan üç ana gruba ayrılır:

Yaratımsal Kalıplar: Bu kalıplar, nesne yaratma mekanizmalarına odaklanır ve duruma uygun bir şekilde nesneler yaratmaya çalışır. Mevcut kodun esnekliğini ve yeniden kullanımını artırırlar.
Yapısal Kalıplar: Bu kalıplar nesne bileşimi ile ilgilenir, nesnelerin ve sınıfların nasıl daha büyük yapılar oluşturacak şekilde bir araya getirileceğini, bu yapıları esnek ve verimli tutarak açıklar.
Davranışsal Kalıplar: Bu kalıplar algoritmalar ve nesneler arasındaki sorumlulukların atanmasıyla ilgilidir. Nesnelerin nasıl etkileşimde bulunduğunu ve sorumluluğu nasıl dağıttığını tanımlarlar.

Şimdi her kategoriye pratik örneklerle dalalım.

Yaratımsal Kalıplar: Nesne Yaratmada Uzmanlaşmak

Yaratımsal kalıplar, mevcut kodun esnekliğini ve yeniden kullanımını artıran çeşitli nesne yaratma mekanizmaları sunar. Bir sistemin, nesnelerinin nasıl yaratıldığı, birleştirildiği ve temsil edildiğinden ayrıştırılmasına yardımcı olurlar.

Singleton (Tekil Nesne) Kalıbı

Kavram: Singleton kalıbı, bir sınıfın yalnızca bir örneği olmasını sağlar ve ona tek, küresel bir erişim noktası sunar. Yeni bir örnek oluşturma girişimi, her zaman orijinal olanı döndürür.

Yaygın Kullanım Alanları: Bu kalıp, paylaşılan kaynakları veya durumu (state) yönetmek için kullanışlıdır. Örnekler arasında tek bir veritabanı bağlantı havuzu, küresel bir yapılandırma yöneticisi veya uygulama genelinde birleşik olması gereken bir kayıt (logging) hizmeti bulunur.

JavaScript'te Uygulama: Modern JavaScript, özellikle ES6 sınıfları ile bir Singleton uygulamayı basitleştirir. Tek örneği tutmak için sınıf üzerinde statik bir özellik kullanabiliriz.

Örnek: Bir Kayıt Servisi (Logger) Singleton'ı

class Logger { constructor() { if (Logger.instance) { return Logger.instance; } this.logs = []; Logger.instance = this; } log(message) { const timestamp = new Date().toISOString(); this.logs.push({ message, timestamp }); console.log(`${timestamp} - ${message}`); } getLogCount() { return this.logs.length; } } // 'new' anahtar kelimesi çağrılır, ancak constructor mantığı tek bir örnek olmasını sağlar. const logger1 = new Logger(); const logger2 = new Logger(); console.log("Kayıtçılar aynı örnek mi?", logger1 === logger2); // true logger1.log("logger1'den ilk mesaj."); logger2.log("logger2'den ikinci mesaj."); console.log("Toplam kayıt:", logger1.getLogCount()); // 2

Artıları ve Eksileri:

Artıları: Tek bir örneği garanti eder, küresel bir erişim noktası sağlar ve ağır nesnelerin birden çok örneğini oluşturmaktan kaçınarak kaynakları korur.
Eksileri: Küresel bir durum (state) yarattığı ve birim testi (unit testing) yapmayı zorlaştırdığı için bir anti-pattern olarak kabul edilebilir. Kodu Singleton örneğine sıkıca bağlayarak bağımlılık enjeksiyonu (dependency injection) ilkesini ihlal eder.

Factory (Fabrika) Kalıbı

Kavram: Factory kalıbı, bir üst sınıfta nesneler oluşturmak için bir arayüz sağlar, ancak alt sınıfların oluşturulacak nesnelerin türünü değiştirmesine olanak tanır. Bu, somut sınıflarını belirtmeden nesneler oluşturmak için özel bir "fabrika" yöntemi veya sınıfı kullanmakla ilgilidir.

Yaygın Kullanım Alanları: Bir sınıfın oluşturması gereken nesnelerin türünü öngöremediği durumlarda veya kütüphanenizin kullanıcılarına, iç uygulama ayrıntılarını bilmelerine gerek kalmadan nesneler oluşturma yolu sağlamak istediğinizde kullanılır. Yaygın bir örnek, bir parametreye göre farklı türde kullanıcılar (Yönetici, Üye, Misafir) oluşturmaktır.

JavaScript'te Uygulama:

Örnek: Bir Kullanıcı Fabrikası

class RegularUser { constructor(name) { this.name = name; this.role = 'Regular'; } viewDashboard() { console.log(`${this.name} kullanıcı panosunu görüntülüyor.`); } } class AdminUser { constructor(name) { this.name = name; this.role = 'Admin'; } viewDashboard() { console.log(`${this.name} yönetici panosunu tam yetkilerle görüntülüyor.`); } } class UserFactory { static createUser(type, name) { switch (type.toLowerCase()) { case 'admin': return new AdminUser(name); case 'regular': return new RegularUser(name); default: throw new Error('Geçersiz kullanıcı türü belirtildi.'); } } } const admin = UserFactory.createUser('admin', 'Alice'); const regularUser = UserFactory.createUser('regular', 'Bob'); admin.viewDashboard(); // Alice yönetici panosunu görüntülüyor... regularUser.viewDashboard(); // Bob kullanıcı panosunu görüntülüyor. console.log(admin.role); // Admin console.log(regularUser.role); // Regular

Artıları ve Eksileri:

Artıları: İstemci kodunu somut sınıflardan ayırarak gevşek bağlılığı teşvik eder. Yeni ürün türleri eklemek yalnızca yeni bir sınıf oluşturmayı ve fabrikayı güncellemeyi gerektirdiğinden kodu daha genişletilebilir hale getirir.
Eksileri: Çok sayıda farklı ürün türü gerekiyorsa, sınıf sayısında bir artışa yol açabilir ve bu da kod tabanını daha karmaşık hale getirebilir.

Prototype (Prototip) Kalıbı

Kavram: Prototype kalıbı, "prototip" olarak bilinen mevcut bir nesneyi kopyalayarak yeni nesneler oluşturmakla ilgilidir. Bir nesneyi sıfırdan oluşturmak yerine, önceden yapılandırılmış bir nesnenin klonunu oluşturursunuz. Bu, JavaScript'in kendisinin prototipsel kalıtım yoluyla çalışma şeklinin temelidir.

Yaygın Kullanım Alanları: Bu kalıp, bir nesne oluşturma maliyetinin mevcut bir nesneyi kopyalamaktan daha pahalı veya karmaşık olduğu durumlarda kullanışlıdır. Ayrıca, türü çalışma zamanında belirtilen nesneler oluşturmak için de kullanılır.

JavaScript'te Uygulama: JavaScript, `Object.create()` aracılığıyla bu kalıp için yerleşik desteğe sahiptir.

Örnek: Klonlanabilir Araç Prototipi

Artıları ve Eksileri:

Artıları: Karmaşık nesneler oluşturmak için önemli bir performans artışı sağlayabilir. Çalışma zamanında nesnelere özellik eklemenize veya çıkarmanıza olanak tanır.
Eksileri: Döngüsel referanslara sahip nesnelerin klonlarını oluşturmak zor olabilir. Derin bir kopya gerekebilir, bu da doğru bir şekilde uygulanması karmaşık olabilir.

Yapısal Kalıplar: Kodu Akıllıca Birleştirmek

Yapısal kalıplar, nesnelerin ve sınıfların daha büyük, daha karmaşık yapılar oluşturmak için nasıl birleştirilebileceği ile ilgilidir. Yapıyı basitleştirmeye ve ilişkileri tanımlamaya odaklanırlar.

Adapter (Adaptör) Kalıbı

Kavram: Adapter kalıbı, iki uyumsuz arayüz arasında bir köprü görevi görür. Bağımsız veya uyumsuz arayüzlerin işlevselliklerini birleştiren tek bir sınıfı (adaptör) içerir. Bunu, cihazınızı yabancı bir elektrik prizine takmanıza izin veren bir güç adaptörü gibi düşünün.

Yaygın Kullanım Alanları: Farklı bir API bekleyen mevcut bir uygulamayla yeni bir üçüncü taraf kütüphanesini entegre etmek veya eski kodu yeniden yazmadan modern bir sistemle çalışmasını sağlamak.

JavaScript'te Uygulama:

Örnek: Yeni Bir API'yi Eski Bir Arayüze Uyarlamak

// Uygulamamızın kullandığı eski, mevcut arayüz class OldCalculator { operation(term1, term2, operation) { switch (operation) { case 'add': return term1 + term2; case 'sub': return term1 - term2; default: return NaN; } } } // Farklı bir arayüze sahip yeni, parlak kütüphane class NewCalculator { add(term1, term2) { return term1 + term2; } subtract(term1, term2) { return term1 - term2; } } // Adaptör sınıfı class CalculatorAdapter { constructor() { this.calculator = new NewCalculator(); } operation(term1, term2, operation) { switch (operation) { case 'add': // Çağrıyı yeni arayüze uyarlama return this.calculator.add(term1, term2); case 'sub': return this.calculator.subtract(term1, term2); default: return NaN; } } } // İstemci kodu artık adaptörü eski hesap makinesiymiş gibi kullanabilir const oldCalc = new OldCalculator(); console.log("Eski hesap makinesi sonucu:", oldCalc.operation(10, 5, 'add')); // 15 const adaptedCalc = new CalculatorAdapter(); console.log("Uyarlanmış hesap makinesi sonucu:", adaptedCalc.operation(10, 5, 'add')); // 15

Artıları ve Eksileri:

Artıları: İstemciyi hedef arayüzün uygulamasından ayırarak farklı uygulamaların birbirinin yerine kullanılmasını sağlar. Kodun yeniden kullanılabilirliğini artırır.
Eksileri: Koda ekstra bir karmaşıklık katmanı ekleyebilir.

Decorator (Dekoratör/Süsleyici) Kalıbı

Kavram: Decorator kalıbı, bir nesnenin orijinal kodunu değiştirmeden ona dinamik olarak yeni davranışlar veya sorumluluklar eklemenizi sağlar. Bu, orijinal nesneyi yeni işlevselliği içeren özel bir "dekoratör" nesnesiyle sarmalayarak elde edilir.

Yaygın Kullanım Alanları: Bir kullanıcı arayüzü bileşenine özellikler eklemek, bir kullanıcı nesnesini izinlerle zenginleştirmek veya bir hizmete kayıt/önbellekleme davranışı eklemek. Alt sınıflamaya esnek bir alternatiftir.

JavaScript'te Uygulama: JavaScript'te fonksiyonlar birinci sınıf vatandaşlardır, bu da dekoratörleri uygulamayı kolaylaştırır.

Örnek: Bir Kahve Siparişini Süslemek

// Temel bileşen class SimpleCoffee { getCost() { return 10; } getDescription() { return 'Sade kahve'; } } // Dekoratör 1: Süt function MilkDecorator(coffee) { const originalCost = coffee.getCost(); const originalDescription = coffee.getDescription(); coffee.getCost = function() { return originalCost + 2; }; coffee.getDescription = function() { return `${originalDescription}, sütlü`; }; return coffee; } // Dekoratör 2: Şeker function SugarDecorator(coffee) { const originalCost = coffee.getCost(); const originalDescription = coffee.getDescription(); coffee.getCost = function() { return originalCost + 1; }; coffee.getDescription = function() { return `${originalDescription}, şekerli`; }; return coffee; } // Bir kahve oluşturalım ve süsleyelim let myCoffee = new SimpleCoffee(); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 10, Sade kahve myCoffee = MilkDecorator(myCoffee); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 12, Sade kahve, sütlü myCoffee = SugarDecorator(myCoffee); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 13, Sade kahve, sütlü, şekerli

Artıları ve Eksileri:

Artıları: Çalışma zamanında nesnelere sorumluluk eklemek için büyük esneklik sağlar. Hiyerarşinin üst kısımlarında özelliklerle şişirilmiş sınıflardan kaçınır.
Eksileri: Çok sayıda küçük nesneyle sonuçlanabilir. Dekoratörlerin sırası önemli olabilir, bu da istemciler için açık olmayabilir.

Facade (Cephe) Kalıbı

Kavram: Facade kalıbı, karmaşık bir sınıf, kütüphane veya API alt sistemine basitleştirilmiş, üst düzey bir arayüz sağlar. Altta yatan karmaşıklığı gizler ve alt sistemin kullanımını kolaylaştırır.

Yaygın Kullanım Alanları: Envanter, ödeme ve kargo alt sistemlerini içeren bir e-ticaret ödeme süreci gibi karmaşık bir dizi eylem için basit bir API oluşturmak. Başka bir örnek, dahili olarak sunucuyu, veritabanını ve ara yazılımı (middleware) yapılandıran bir web uygulamasını başlatmak için tek bir yöntemdir.

JavaScript'te Uygulama:

Örnek: Bir Konut Kredisi Başvuru Cephesi

// Karmaşık Alt Sistemler class BankService { verify(name, amount) { console.log(`${name} için ${amount} tutarında yeterli bakiye doğrulanıyor`); return amount < 100000; } } class CreditHistoryService { get(name) { console.log(`${name} için kredi geçmişi kontrol ediliyor`); // İyi bir kredi puanı simüle et return true; } } class BackgroundCheckService { run(name) { console.log(`${name} için adli sicil kaydı kontrolü yapılıyor`); return true; } } // Cephe (Facade) class MortgageFacade { constructor() { this.bank = new BankService(); this.credit = new CreditHistoryService(); this.background = new BackgroundCheckService(); } applyFor(name, amount) { console.log(`--- ${name} için konut kredisi başvurusu yapılıyor ---`); const isEligible = this.bank.verify(name, amount) && this.credit.get(name) && this.background.run(name); const result = isEligible ? 'Onaylandı' : 'Reddedildi'; console.log(`--- ${name} için başvuru sonucu: ${result} ---\n`); return result; } } // İstemci kodu basit Cephe ile etkileşime girer const mortgage = new MortgageFacade(); mortgage.applyFor('John Smith', 75000); // Onaylandı mortgage.applyFor('Jane Doe', 150000); // Reddedildi

Artıları ve Eksileri:

Artıları: İstemciyi bir alt sistemin karmaşık iç işleyişinden ayırarak okunabilirliği ve bakımı iyileştirir.
Eksileri: Cephe, bir alt sistemin tüm sınıflarına bağlı bir "tanrı nesnesi" (god object) haline gelebilir. İstemcilerin daha fazla esnekliğe ihtiyaç duymaları halinde alt sistem sınıflarına doğrudan erişmelerini engellemez.

Davranışsal Kalıplar: Nesne İletişimini Yönetmek

Davranışsal kalıplar, nesnelerin birbirleriyle nasıl iletişim kurduğuyla ilgilidir ve sorumlulukları atamaya ve etkileşimleri etkili bir şekilde yönetmeye odaklanır.

Observer (Gözlemci) Kalıbı

Kavram: Observer kalıbı, nesneler arasında bire-çok bir bağımlılık tanımlar. Bir nesne ("subject" veya "observable") durumunu değiştirdiğinde, tüm bağımlı nesneleri ("observers") otomatik olarak bilgilendirilir ve güncellenir.

Yaygın Kullanım Alanları: Bu kalıp, olay güdümlü programlamanın temelidir. UI geliştirmede (DOM olay dinleyicileri), durum yönetimi kütüphanelerinde (Redux veya Vuex gibi) ve mesajlaşma sistemlerinde yoğun olarak kullanılır.

JavaScript'te Uygulama:

Örnek: Bir Haber Ajansı ve Aboneler

// Subject (Gözlemlenen) class NewsAgency { constructor() { this.subscribers = []; } subscribe(subscriber) { this.subscribers.push(subscriber); console.log(`${subscriber.name} abone oldu.`); } unsubscribe(subscriber) { this.subscribers = this.subscribers.filter(sub => sub !== subscriber); console.log(`${subscriber.name} abonelikten çıktı.`); } notify(news) { console.log(`--- HABER AJANSI: Haber yayınlanıyor: "${news}" ---`); this.subscribers.forEach(subscriber => subscriber.update(news)); } } // Observer (Gözlemci) class Subscriber { constructor(name) { this.name = name; } update(news) { console.log(`${this.name} son haberi aldı: "${news}"`); } } const agency = new NewsAgency(); const sub1 = new Subscriber('Okuyucu A'); const sub2 = new Subscriber('Okuyucu B'); const sub3 = new Subscriber('Okuyucu C'); agency.subscribe(sub1); agency.subscribe(sub2); agency.notify('Küresel piyasalar yükselişte!'); agency.subscribe(sub3); agency.unsubscribe(sub2); agency.notify('Yeni teknoloji atılımı duyuruldu!');

Artıları ve Eksileri:

Artıları: Subject ve observer'ları arasında gevşek bağlılığı teşvik eder. Subject, observer arayüzünü uyguladıkları dışında observer'ları hakkında hiçbir şey bilmek zorunda değildir. Yayın tarzı (broadcast-style) bir iletişimi destekler.
Eksileri: Observer'lar öngörülemeyen bir sırayla bilgilendirilir. Çok sayıda observer varsa veya güncelleme mantığı karmaşıksa performans sorunlarına yol açabilir.

Strategy (Strateji) Kalıbı

Kavram: Strategy kalıbı, bir dizi değiştirilebilir algoritma tanımlar ve her birini kendi sınıfında kapsüller. Bu, algoritmanın onu kullanan istemciden bağımsız olarak çalışma zamanında seçilip değiştirilmesine olanak tanır.

Yaygın Kullanım Alanları: Farklı sıralama algoritmaları, doğrulama kuralları veya bir e-ticaret sitesi için kargo maliyeti hesaplama yöntemleri (örneğin, sabit oran, ağırlığa göre, varış noktasına göre) uygulamak.

JavaScript'te Uygulama:

Örnek: Kargo Ücreti Hesaplama Stratejisi

// Context (Bağlam) class Shipping { constructor() { this.company = null; } setStrategy(company) { this.company = company; console.log(`Kargo stratejisi şuna ayarlandı: ${company.constructor.name}`); } calculate(pkg) { if (!this.company) { throw new Error('Kargo stratejisi ayarlanmadı.'); } return this.company.calculate(pkg); } } // Stratejiler class FedExStrategy { calculate(pkg) { // Ağırlığa vb. dayalı karmaşık hesaplama. const cost = pkg.weight * 2.5 + 5; console.log(`FedEx maliyeti, ${pkg.weight}kg'lık paket için $${cost}`); return cost; } } class UPSStrategy { calculate(pkg) { const cost = pkg.weight * 2.1 + 4; console.log(`UPS maliyeti, ${pkg.weight}kg'lık paket için $${cost}`); return cost; } } class PostalServiceStrategy { calculate(pkg) { const cost = pkg.weight * 1.8; console.log(`Posta Servisi maliyeti, ${pkg.weight}kg'lık paket için $${cost}`); return cost; } } const shipping = new Shipping(); const packageA = { from: 'New York', to: 'London', weight: 5 }; shipping.setStrategy(new FedExStrategy()); shipping.calculate(packageA); shipping.setStrategy(new UPSStrategy()); shipping.calculate(packageA); shipping.setStrategy(new PostalServiceStrategy()); shipping.calculate(packageA);

Artıları ve Eksileri:

Artıları: Karmaşık bir `if/else` veya `switch` ifadesine temiz bir alternatif sunar. Algoritmaları kapsülleyerek test edilmelerini ve bakımlarını kolaylaştırır.
Eksileri: Bir uygulamadaki nesne sayısını artırabilir. İstemciler, doğru olanı seçmek için farklı stratejilerden haberdar olmalıdır.

Modern Kalıplar ve Mimari Değerlendirmeler

Klasik tasarım kalıpları zamansız olsa da, JavaScript ekosistemi gelişerek günümüz geliştiricileri için çok önemli olan modern yorumlamalara ve büyük ölçekli mimari kalıplara yol açmıştır.

Modül Kalıbı

Modül kalıbı, özel ve genel kapsama alanları oluşturmak için ES6 öncesi JavaScript'teki en yaygın kalıplardan biriydi. Durumu ve davranışı kapsüllemek için closure'ları kullanır. Bugün, bu kalıp büyük ölçüde, standartlaştırılmış, dosya tabanlı bir modül sistemi sağlayan yerel ES6 Modülleri (`import`/`export`) tarafından geçersiz kılınmıştır. ES6 modüllerini anlamak, hem ön-yüz hem de arka-yüz uygulamalarında kodu düzenlemek için standart oldukları için her modern JavaScript geliştiricisi için temeldir.

Mimari Kalıplar (MVC, MVVM)

Tasarım kalıpları ile mimari kalıplar arasında ayrım yapmak önemlidir. Tasarım kalıpları belirli, yerel sorunları çözerken, mimari kalıplar tüm bir uygulama için üst düzey bir yapı sağlar.

MVC (Model-View-Controller): Bir uygulamayı üç birbiriyle bağlantılı bileşene ayıran bir kalıp: Model (veri ve iş mantığı), View (kullanıcı arayüzü) ve Controller (kullanıcı girdisini işler ve Model/View'i günceller). Ruby on Rails ve Angular'ın eski sürümleri gibi framework'ler bunu popülerleştirdi.
MVVM (Model-View-ViewModel): MVC'ye benzer, ancak Model ve View arasında bir bağlayıcı görevi gören bir ViewModel içerir. ViewModel, verileri ve komutları ortaya çıkarır ve View, veri bağlama (data-binding) sayesinde otomatik olarak güncellenir. Bu kalıp, Vue.js gibi modern framework'lerin merkezindedir ve React'in bileşen tabanlı mimarisinde etkilidir.

React, Vue veya Angular gibi framework'lerle çalışırken, sağlam uygulamalar oluşturmak için doğal olarak bu mimari kalıpları, genellikle daha küçük tasarım kalıplarıyla (durum yönetimi için Observer kalıbı gibi) birleştirerek kullanırsınız.

Sonuç: Kalıpları Akıllıca Kullanmak

JavaScript tasarım kalıpları katı kurallar değil, bir geliştiricinin cephaneliğindeki güçlü araçlardır. Yazılım mühendisliği topluluğunun kolektif bilgeliğini temsil eder ve yaygın sorunlara zarif çözümler sunarlar.

Onlarda ustalaşmanın anahtarı, her kalıbı ezberlemek değil, her birinin çözdüğü sorunu anlamaktır. Kodunuzda bir zorlukla karşılaştığınızda - bu ister sıkı bağlılık, ister karmaşık nesne oluşturma veya esnek olmayan algoritmalar olsun - o zaman iyi tanımlanmış bir çözüm olarak uygun kalıba yönelebilirsiniz.

Son tavsiyemiz şudur: İşe yarayan en basit kodu yazarak başlayın. Uygulamanız geliştikçe, kodunuzu doğal olarak uydukları yerlerde bu kalıplara doğru yeniden düzenleyin (refactor). Gerekli olmadığı yerde bir kalıbı zorla kullanmayın. Onları akıllıca uygulayarak, sadece işlevsel değil, aynı zamanda temiz, ölçeklenebilir ve gelecek yıllarda bakımı keyifli olan bir kod yazacaksınız.