想象一下在没有手册的情况下拼搭一套乐高积木。当然，你最终可能会得到一些隐约类似于宇宙飞船的东西，但更有可能的是，你最终会得到一堆色彩缤纷的混乱。在编码世界中，设计模式就像乐高手册——它们为您提供了解决常见问题的经过验证的蓝图，使您的代码更干净、更高效、更易于维护。
但是别担心，这不是一个关于编码原理的枯燥讲座。将其视为 JavaScript 中一些最常见设计模式的有趣小指南，并附有现实生活中的类比，使这些概念易于理解。
单例模式确保一个类只有一个实例并提供对其的全局访问点。这就像你的电视有一个遥控器。您不需要多个遥控器来控制音量、更改频道或关闭它 - 只需一个遥控器即可。
在 JavaScript 中，此模式通常用于管理全局应用程序状态。例如，如果您在电子商务网站上有一个购物车，您希望与购物车交互的所有组件（例如添加商品、删除商品或结账）都引用购物车的同一实例。单例确保所有这些操作影响同一个购物车，而不是它的不同副本。
class ShoppingCart {
constructor() {
if (!ShoppingCart.instance) {
this.items = [];
ShoppingCart.instance = this;
}
return ShoppingCart.instance;
}
addItem(item) {
this.items.push(item);
}
getItems() {
return this.items;
}
}
const cart1 = new ShoppingCart();
const cart2 = new ShoppingCart();
cart1.addItem('Laptop');
console.log(cart2.getItems()); // ['Laptop']
观察者模式就是为了保持对象同步。当一个对象发生变化时，其他对象需要知道它。这就像一个群聊，每个人都会不断了解正在发生的事情。如果有人改变周末计划，小组中的每个人都会收到备忘录。
在 JavaScript 中，这种模式经常用于事件处理系统。假设您正在构建一个社交媒体应用程序。当有人喜欢某个帖子时，您想要更新喜欢计数，通知帖子的作者，并且可能触发动画。观察者模式允许这些不同的组件在不直接连接的情况下保持更新。
class Subject {
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(`Observer received: ${data}`);
}
}
const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();
subject.subscribe(observer1);
subject.subscribe(observer2);
subject.notify('New post liked!');
// Output: Observer received: New post liked!
// Output: Observer received: New post liked!
工厂模式就是创建对象，而不指定将创建的对象的确切类。想象一下饼干切割机。在按下切刀之前，你并不知道面团会变成什么形状，但你知道你会得到一块饼干。
当您拥有一组共享公共接口或结构但具有不同底层实现的对象时，此模式特别有用。例如，在游戏中，您可能有不同类型的敌人（僵尸、吸血鬼、狼人），但它们都具有共同的属性，例如生命值、速度和攻击力。工厂可以帮助您创建这些敌人，而无需担心具体类型。
class Enemy {
constructor(type) {
this.type = type;
this.health = 100;
}
attack() {
console.log(`${this.type} attacks with ${this.attackPower}`);
}
}
class EnemyFactory {
createEnemy(type) {
let enemy;
if (type === 'zombie') {
enemy = new Enemy('Zombie');
enemy.attackPower = 10;
} else if (type === 'vampire') {
enemy = new Enemy('Vampire');
enemy.attackPower = 20;
} else if (type === 'werewolf') {
enemy = new Enemy('Werewolf');
enemy.attackPower = 30;
}
return enemy;
}
}
const factory = new EnemyFactory();
const zombie = factory.createEnemy('zombie');
zombie.attack(); // Zombie attacks with 10
const vampire = factory.createEnemy('vampire');
vampire.attack(); // Vampire attacks with 20
模块模式就像拥有一个组织良好的工作空间，所有东西都有它的位置。它可以帮助您组织和封装代码的不同部分，防止全局命名空间变得混乱。
此模式在 JavaScript 中对于创建公共和私有变量和函数特别有用。例如，当您构建库或插件时，您可能希望向外界公开某些方法，同时隐藏其他方法。模块模式可以让您做到这一点。
const Calculator = (function() {
let result = 0;
function add(x) {
result += x;
return result;
}
function subtract(x) {
result -= x;
return result;
}
function multiply(x) {
result *= x;
return result;
}
function divide(x) {
if (x !== 0) {
result /= x;
return result;
} else {
console.error('Cannot divide by zero');
}
}
return {
add,
subtract,
multiply,
divide,
getResult: () => result,
};
})();
console.log(Calculator.add(10)); // 10
console.log(Calculator.subtract(2)); // 8
console.log(Calculator.multiply(3)); // 24
console.log(Calculator.divide(4)); // 6
适配器模式允许不兼容的接口一起工作。您可以将其想象为出国旅行时使用的插头适配器。您的笔记本电脑充电器的插头可能无法插入其他国家/地区的墙壁插座，但只要使用正确的适配器，它就可以完美工作。
在 JavaScript 中，当您与与应用程序结构不完全匹配的第三方库或 API 集成时，您可能会使用适配器模式。 Adapter 可以将一个类的接口转换为客户期望的另一个接口，从而实现无缝集成。
class OldApi {
constructor() {
this.data = 'Old API data';
}
getData() {
return this.data;
}
}
class NewApi {
fetchData() {
return 'New API data';
}
}
class ApiAdapter {
constructor(oldApi) {
this.oldApi = oldApi;
}
fetchData() {
return this.oldApi.getData();
}
}
const oldApi = new OldApi();
const adapter = new ApiAdapter(oldApi);
console.log(adapter.fetchData()); // 'Old API data'
The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It’s like Russian nesting dolls where each doll is part of a larger structure, but you can interact with them both as individual dolls and as a nested set.
This pattern is often used in scenarios where you need to manage a hierarchy of objects. For example, consider a file system where files and folders are represented as objects. A folder can contain multiple files or even other folders, and you want to treat both files and folders similarly when it comes to operations like moving, copying, or deleting.
class File {
constructor(name) {
this.name = name;
}
display() {
console.log(this.name);
}
}
class Folder {
constructor(name) {
this.name = name;
this.children = [];
}
add(child) {
this.children.push(child);
}
display() {
console.log(this.name);
this.children.forEach(child => child.display());
}
}
const file1 = new File('file1.txt');
const file2 = new File('file2.txt');
const folder = new Folder('MyFolder');
folder.add(file1);
folder.add(file2);
folder.display();
// Output:
// MyFolder
// file1.txt
// file2.txt
These are just a few of the many design patterns that can make your JavaScript code more robust, maintainable, and, let’s face it, fun to write. Whether you’re building the next big app or just trying to organize your code a bit better, these patterns can be your secret weapon. So next time you’re stuck, remember: there’s probably a pattern for that!
And hey, even if your code doesn’t end up looking like a LEGO spaceship, at least it won’t be a pile of colorful chaos.
Happy coding! ?
以上是软件设计模式：每个优秀应用程序背后的秘密武器的详细内容。更多信息请关注PHP中文网其他相关文章！
