想像一下：您站在廚房裡準備做飯。你已經準備好了所有的原料，但你缺少一個可以遵循的食譜。你開始嘗試，但很快你就感到不知所措。你在一道菜中加了太多鹽，燒焦了另一道菜。如果沒有明確的計劃，烹飪就會變成一團亂猜。
創建軟體就像這樣。您擁有所有工具和專業知識，但如果沒有良好組織的方法，添加新功能可能會成為一個令人沮喪的難題。您是否了解您的程式碼需要做什麼，但是您是否正在找出使所有內容協同工作的最佳方法？這就是事情變得複雜的地方。一個微小的錯誤，你會發現自己掉進了一個充滿錯誤和混亂程式碼的洞。
輸入設計模式－程式設計師多年來傳承下來的經過時間考驗的秘訣。這些可重複使用的修復程序可以幫助您毫不費力地處理製作軟體的棘手部分。我們將了解設計模式到底是什麼，它們如何使您的編碼生活更輕鬆，以及為什麼它們是建立健壯、易於維護的應用程式的關鍵。為了讓事情變得更有趣，我們將在整個解釋中使用烹飪術語 - 因為，說實話，誰不喜歡精彩的烹飪節目？
那麼，什麼是設計模式呢？他們將如何幫助我們建立更好的應用程式？
設計模式是一種可重複使用的解決方案模板，可應用於軟體設計中反覆出現的問題和主題。這將是一本很好的食譜，其中包含經驗豐富的開發人員針對軟體設計常見問題進行嘗試和測試的解決方案。該指南指出，透過設計模式，我們可以在應用程式中實現可維護和可重複使用的程式碼。
設計模式本質上依其解決的問題分為三大類：創造型設計模式、結構型設計模式、行為型設計模式。
設計模式依其解決的問題分為三類。它們是創造型設計模式、結構型設計模式和行為型設計模式。
創意設計模式：原料與準備
創建設計模式提供了創建物件的機制。在烹飪節目的背景下，這些模式就像烹飪前收集和準備食材一樣。屬於此類別的一些模式包括建構函數、工廠、抽象、原型、單例和生成器。為了更好地理解，請看下面的三個範例。
1。辛格頓
想像一下，有一些家庭的秘密醬汁，只能在一些特殊的鍋子裡製作，代代相傳。當然，鍋子不同，醬汁的味道也不可能一樣。這幾乎就是 Singleton 所做的：一種設計模式，其中類別僅限於具有單一實例。
class SecretSauce {
constructor() {
if (SecretSauce.instance) {
return SecretSauce.instance;
}
SecretSauce.instance = this;
this.flavor = 'Umami';
}
getFlavor() {
return this.flavor;
}
}
const sauce1 = new SecretSauce();
const sauce2 = new SecretSauce();
console.log(sauce1.getFlavor() === sauce2.getFlavor()); // true
登入後複製
2。工廠方法
工廠方法提供了創建物件的通用接口，允許我們指定我們想要的物件類型。在我們的烹飪節目中，食譜書就是工廠。根據您想要製作的菜餚類型，它會給您所需的食譜（物件）。
// Product Classes
class Pizza {
constructor(size, toppings) {
this.size = size;
this.toppings = toppings;
}
prepare() {
console.log(`Preparing a ${this.size} pizza with ${this.toppings.join(', ')} toppings.`);
}
}
class Pasta {
constructor(sauce, noodles) {
this.sauce = sauce;
this.noodles = noodles;
}
prepare() {
console.log(`Preparing pasta with ${this.noodles} noodles and ${this.sauce} sauce.`);
}
}
// Creator Class
class RecipeBook {
createDish(type, options) {
let dish;
if (type === 'Pizza') {
dish = new Pizza(options.size, options.toppings);
} else if (type === 'Pasta') {
dish = new Pasta(options.sauce, options.noodles);
}
return dish;
}
}
// Usage
const recipeBook = new RecipeBook();
const pizzaOptions = {
size: 'large',
toppings: ['cheese', 'pepperoni', 'olives']
};
const pastaOptions = {
sauce: 'alfredo',
noodles: 'fettuccine'
};
const pizza = recipeBook.createDish('Pizza', pizzaOptions);
const pasta = recipeBook.createDish('Pasta', pastaOptions);
pizza.prepare(); // Preparing a large pizza with cheese, pepperoni, olives toppings.
pasta.prepare(); // Preparing pasta with fettuccine noodles and alfredo sauce.
登入後複製
工廠方法在創建複雜物件的場景中會派上用場，例如根據環境產生不同的實例或管理許多相似的物件。
*3。抽象工廠 *
它封裝了物件一般用法的實作細節。解釋這一點的最好方法是，如果您考慮提供餐包送貨服務：無論您烹飪意大利菜、中國菜還是墨西哥菜，這項服務都將提供包含食材和食譜的所有食物，僅根據手頭的菜餚量身定制，因此一切都完美契合。
// Abstract Factory Interfaces
class ItalianKitchen {
createPizza(options) {
return new Pizza(options.size, options.toppings);
}
createPasta(options) {
return new Pasta(options.sauce, options.noodles);
}
}
class MexicanKitchen {
createTaco(options) {
return new Taco(options.shellType, options.fillings);
}
createBurrito(options) {
return new Burrito(options.size, options.fillings);
}
}
// Concrete Product Classes
class Pizza {
constructor(size, toppings) {
this.size = size;
this.toppings = toppings;
}
prepare() {
console.log(`Preparing a ${this.size} pizza with ${this.toppings.join(', ')} toppings.`);
}
}
class Pasta {
constructor(sauce, noodles) {
this.sauce = sauce;
this.noodles = noodles;
}
prepare() {
console.log(`Preparing pasta with ${this.noodles} noodles and ${this.sauce} sauce.`);
}
}
class Taco {
constructor(shellType, fillings) {
this.shellType = shellType;
this.fillings = fillings;
}
prepare() {
console.log(`Preparing a taco with a ${this.shellType} shell and ${this.fillings.join(', ')} fillings.`);
}
}
class Burrito {
constructor(size, fillings) {
this.size = size;
this.fillings = fillings;
}
prepare() {
console.log(`Preparing a ${this.size} burrito with ${this.fillings.join(', ')} fillings.`);
}
}
// Client Code
const italianKitchen = new ItalianKitchen();
const mexicanKitchen = new MexicanKitchen();
const italianPizza = italianKitchen.createPizza({
size: 'medium',
toppings: ['mozzarella', 'tomato', 'basil']
});
const mexicanTaco = mexicanKitchen.createTaco({
shellType: 'hard',
fillings: ['beef', 'lettuce', 'cheese']
});
italianPizza.prepare(); // Preparing a medium pizza with mozzarella, tomato, basil toppings.
mexicanTaco.prepare(); // Preparing a taco with a hard shell and beef, lettuce, cheese fillings.
登入後複製
結構設計模式：烹飪技術與工具
結構設計模式著重於物件組合，確定在不同物件之間建立關係的簡單方法。它們有助於確保當系統的某一部分發生變化時，整體結構保持穩定。在烹飪中，這些圖案代表了我們將食材組合成和諧美味菜餚的技術和工具。
屬於此類別的模式包括裝飾器、外觀、享元、適配器和代理。
1。外觀圖案
外觀模式為更複雜的代碼體提供了方便的高級接口，有效地隱藏了底層的複雜性。想像一下，一位副主廚為主廚簡化了複雜的任務。副主廚收集食材、準備它們並組織一切，以便主廚可以專注於菜餚的最後潤色
// Complex Subsystem
class IngredientPrep {
chop(ingredient) {
console.log(`Chopping ${ingredient}.`);
}
measure(amount, ingredient) {
console.log(`Measuring ${amount} of ${ingredient}.`);
}
}
class CookingProcess {
boil(waterAmount) {
console.log(`Boiling ${waterAmount} of water.`);
}
bake(temp, duration) {
console.log(`Baking at ${temp} degrees for ${duration} minutes.`);
}
}
class Plating {
arrangeDish(dish) {
console.log(`Arranging the ${dish} on the plate.`);
}
garnish(garnish) {
console.log(`Adding ${garnish} as garnish.`);
}
}
// Facade Class
class SousChef {
constructor() {
this.ingredientPrep = new IngredientPrep();
this.cookingProcess = new CookingProcess();
this.plating = new Plating();
}
prepareDish(dishName) {
console.log(`Starting to prepare ${dishName}...`);
this.ingredientPrep.chop('vegetables');
this.ingredientPrep.measure('2 cups', 'flour');
this.cookingProcess.boil('1 liter');
this.cookingProcess.bake(180, 30);
this.plating.arrangeDish(dishName);
this.plating.garnish('parsley');
console.log(`${dishName} is ready!`);
}
}
// Client Code
const sousChef = new SousChef();
sousChef.prepareDish('Lasagna');
// Output:
// Starting to prepare Lasagna...
// Chopping vegetables.
// Measuring 2 cups of flour.
// Boiling 1 liter of water.
// Baking at 180 degrees for 30 minutes.
// Arranging the Lasagna on the plate.
// Adding parsley as garnish.
// Lasagna is ready!
登入後複製
2. Decorator
The Decorator pattern is used to modify existing systems by adding features to objects without significantly altering the underlying code. If our applications require many distinct types of objects, this pattern is ideal. For instance, when making coffee, we start with a basic cup and then dynamically add ingredients like milk, sugar, or whipped cream. The Decorator pattern lets us add the base coffee without changing the core recipe.
// Base Component
class Coffee {
constructor() {
this.description = 'Basic Coffee';
}
getDescription() {
return this.description;
}
cost() {
return 2; // Base cost for a simple coffee
}
}
// Decorator Class
class CoffeeDecorator {
constructor(coffee) {
this.coffee = coffee;
}
getDescription() {
return this.coffee.getDescription();
}
cost() {
return this.coffee.cost();
}
}
// Concrete Decorators
class Milk extends CoffeeDecorator {
constructor(coffee) {
super(coffee);
}
getDescription() {
return `${this.coffee.getDescription()}, Milk`;
}
cost() {
return this.coffee.cost() + 0.5;
}
}
class Sugar extends CoffeeDecorator {
constructor(coffee) {
super(coffee);
}
getDescription() {
return `${this.coffee.getDescription()}, Sugar`;
}
cost() {
return this.coffee.cost() + 0.2;
}
}
class WhippedCream extends CoffeeDecorator {
constructor(coffee) {
super(coffee);
}
getDescription() {
return `${this.coffee.getDescription()}, Whipped Cream`;
}
cost() {
return this.coffee.cost() + 0.7;
}
}
// Client Code
let myCoffee = new Coffee();
console.log(`${myCoffee.getDescription()} costs $${myCoffee.cost()}`); // Basic Coffee costs $2
myCoffee = new Milk(myCoffee);
console.log(`${myCoffee.getDescription()} costs $${myCoffee.cost()}`); // Basic Coffee, Milk costs $2.5
myCoffee = new Sugar(myCoffee);
console.log(`${myCoffee.getDescription()} costs $${myCoffee.cost()}`); // Basic Coffee, Milk, Sugar costs $2.7
myCoffee = new WhippedCream(myCoffee);
console.log(`${myCoffee.getDescription()} costs $${myCoffee.cost()}`); // Basic Coffee, Milk, Sugar, Whipped Cream costs $3.4
登入後複製
3. Flyweight
The Flyweight pattern is a classical structural solution for optimizing code that is repetitive, slow, and inefficiently shares data. It aims to minimize memory in use in an application by sharing as much data as possible with related objects. Think of common ingredients like salt, pepper, and olive oil that are used in many dishes. Instead of having separate instances of these ingredients for each dish, they are shared across dishes to save resources. For example, you put salt on fried chicken and beef stew from the same jar.
// Flyweight Class
class Ingredient {
constructor(name) {
this.name = name;
}
use() {
console.log(`Using ${this.name}.`);
}
}
// Flyweight Factory
class IngredientFactory {
constructor() {
this.ingredients = {};
}
getIngredient(name) {
if (!this.ingredients[name]) {
this.ingredients[name] = new Ingredient(name);
}
return this.ingredients[name];
}
getTotalIngredientsMade() {
return Object.keys(this.ingredients).length;
}
}
// Client Code
const ingredientFactory = new IngredientFactory();
const salt1 = ingredientFactory.getIngredient('Salt');
const salt2 = ingredientFactory.getIngredient('Salt');
const pepper = ingredientFactory.getIngredient('Pepper');
salt1.use(); // Using Salt.
salt2.use(); // Using Salt.
pepper.use(); // Using Pepper.
console.log(ingredientFactory.getTotalIngredientsMade()); // 2, Salt and Pepper were created only once
console.log(salt1 === salt2); // true, Salt is reused
登入後複製
Behavioral Design Patterns: The Cooking Process and Interaction
Behavioral patterns focus on improving or streamlining the communication between disparate objects in a system. They identify common communication patterns among objects and provide solutions that distribute the communication responsibility among different objects, thereby increasing communication flexibility. In a cooking show, behavioral design patterns are the way we cook the dish, the process of cooking, and how various parts of the kitchen interact with each other to create the final dish. Some of the behavioral patterns are Iterator, Mediator, Observer, and Visitor.
1.Observer
The Observer pattern is used to notify components of state changes. When a subject needs to inform observers about a change, it broadcasts a notification. If an observer no longer wishes to receive updates, they can be removed from the list of observers. For example, once the head chef finishes preparing a dish, all the assistant chefs need to be notified to begin their tasks, such as plating or garnishing. The Observer pattern allows multiple chefs (observers) to be notified when the head chef (subject) completes a dish.
// Subject Class
class HeadChef {
constructor() {
this.chefs = [];
this.dishReady = false;
}
addObserver(chef) {
this.chefs.push(chef);
}
removeObserver(chef) {
this.chefs = this.chefs.filter(c => c !== chef);
}
notifyObservers() {
if (this.dishReady) {
this.chefs.forEach(chef => chef.update(this.dishName));
}
}
prepareDish(dishName) {
this.dishName = dishName;
console.log(`HeadChef: Preparing ${dishName}...`);
this.dishReady = true;
this.notifyObservers();
}
}
// Observer Class
class Chef {
constructor(name) {
this.name = name;
}
update(dishName) {
console.log(`${this.name}: Received notification - ${dishName} is ready!`);
}
}
// Client Code
const headChef = new HeadChef();
const chef1 = new Chef('Chef A');
const chef2 = new Chef('Chef B');
headChef.addObserver(chef1);
headChef.addObserver(chef2);
headChef.prepareDish('Beef Wellington');
// Output:
// HeadChef: Preparing Beef Wellington...
// Chef A: Received notification - Beef Wellington is ready!
// Chef B: Received notification - Beef Wellington is ready!
登入後複製
2. Mediator
The Mediator pattern allows one object to be in charge of the communication between several other objects when an event occurs. While it does sound similar to the Observer pattern, the key difference is that the Mediator handles communication between objects rather than just broadcasting changes. For example, let's think of our kitchen with its grill, bakery, and garnish station sections. A kitchen coordinator (mediator) handles the communication so that all the preparations are done on time.
// Mediator Class
class KitchenCoordinator {
notify(sender, event) {
if (event === 'dishPrepared') {
console.log(`Coordinator: Notifying all stations that ${sender.dishName} is ready.`);
} else if (event === 'orderReceived') {
console.log(`Coordinator: Received order for ${sender.dishName}, notifying preparation stations.`);
}
}
}
// Colleague Classes
class GrillStation {
constructor(coordinator) {
this.coordinator = coordinator;
}
prepareDish(dishName) {
this.dishName = dishName;
console.log(`GrillStation: Grilling ${dishName}.`);
this.coordinator.notify(this, 'dishPrepared');
}
}
class BakeryStation {
constructor(coordinator) {
this.coordinator = coordinator;
}
bakeDish(dishName) {
this.dishName = dishName;
console.log(`BakeryStation: Baking ${dishName}.`);
this.coordinator.notify(this, 'dishPrepared');
}
}
// Client Code
const coordinator = new KitchenCoordinator();
const grillStation = new GrillStation(coordinator);
const bakeryStation = new BakeryStation(coordinator);
grillStation.prepareDish('Steak');
// Output:
// GrillStation: Grilling Steak.
// Coordinator: Notifying all stations that Steak is ready.
bakeryStation.bakeDish('Bread');
// Output:
// BakeryStation: Baking Bread.
// Coordinator: Notifying all stations that Bread is ready.
登入後複製
3. Command
The Command design pattern is an Object Behavioral Pattern that encapsulates the invocation of methods, requests, or operations into a single object and allows both parameterization and pass method calls that can be executed at our discretion. For example, look at how the head chef gives the command below.
// Command Interface
class Command {
execute() {}
}
// Concrete Commands
class GrillCommand extends Command {
constructor(grillStation, dishName) {
super();
this.grillStation = grillStation;
this.dishName = dishName;
}
execute() {
this.grillStation.grill(this.dishName);
}
}
class BakeCommand extends Command {
constructor(bakeryStation, dishName) {
super();
this.bakeryStation = bakeryStation;
this.dishName = dishName;
}
execute() {
this.bakeryStation.bake(this.dishName);
}
}
// Receiver Classes
class GrillStation {
grill(dishName) {
console.log(`GrillStation: Grilling ${dishName}.`);
}
}
class BakeryStation {
bake(dishName) {
console.log(`BakeryStation: Baking ${dishName}.`);
}
}
// Invoker Class
class HeadChef {
setCommand(command) {
this.command = command;
}
executeCommand() {
this.command.execute();
}
}
// Client Code
const grillStation = new GrillStation();
const bakeryStation = new BakeryStation();
const grillCommand = new GrillCommand(grillStation, 'Steak');
const bakeCommand = new BakeCommand(bakeryStation, 'Bread');
const headChef = new HeadChef();
headChef.setCommand(grillCommand);
headChef.executeCommand(); // GrillStation: Grilling Steak.
headChef.setCommand(bakeCommand);
headChef.executeCommand(); // BakeryStation: Baking Bread.
登入後複製
Behavioral patterns can feel similar, so let's highlight their differences:
Observer: When a head chef prepares a dish, several other chefs are informed about it.
Mediator: A coordinator works in the kitchen, facilitating communication between various stations in the kitchen.
Command: The head chef issues commands to grill or bake dishes, encapsulating these actions as objects.
Design patterns give a clear way to fix common issues in software development much like a tidy kitchen and smart cooking methods lead to a good meal. When you get these patterns and put them to use, you make your coding easier and help your apps work better and grow more. It doesn't matter if you're new to coding or have done it for a long time - think of design patterns as trusted recipes passed down by many coders over the years. Try them out, play around with them, and soon you'll find that making strong apps becomes as natural as following a recipe you love. Happy coding!
以上是寫你的程式碼：JavaScript 設計模式的詳細內容。更多資訊請關注PHP中文網其他相關文章！
