目录
责任链模式 / Chain of Responsibility Pattern
责任链模式是一种行为型设计模式，它允许你将请求沿着处理链传递，并由链中的不同对象来处理请求。责任链模式的核心思想是将多个对象组合成一个链，每个对象都可以选择处理请求或将其传递给链中的下一个对象。
责任链模式的意图
责任链模式的意图是将请求的发送者和接收者解耦，并将其组织成一个处理链。请求沿着链传递，直到有一个对象处理它为止。
责任链模式实际例子
一个典型的例子是在软件开发中的异常处理。在一个复杂的系统中，可能会有多个对象负责处理不同类型的异常。责任链模式允许你将这些异常处理对象组合成一个链，每个对象都可以选择处理异常或将其传递给链中的下一个对象。
责任链模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用责任链模式处理请求：
// 请求类
class Request {
constructor(amount) {
this.amount = amount;
}
}
// 处理器基类
class Handler {
constructor() {
this.next = null;
}
setNext(handler) {
this.next = handler;
}
handle(request) {
throw new Error('handle() method must be implemented');
}
}
// 具体处理器类
class ConcreteHandler1 extends Handler {
handle(request) {
if (request.amount <= 100) {
console.log(`ConcreteHandler1: Handling request of amount ${request.amount}`);
} else if (this.next) {
console.log('ConcreteHandler1: Unable to handle request, passing it to next handler');
this.next.handle(request);
} else {
console.log('ConcreteHandler1: Unable to handle request');
}
}
}
class ConcreteHandler2 extends Handler {
handle(request) {
if (request.amount > 100 && request.amount <= 500) {
console.log(`ConcreteHandler2: Handling request of amount ${request.amount}`);
} else if (this.next) {
console.log('ConcreteHandler2: Unable to handle request, passing it to next handler');
this.next.handle(request);
} else {
console.log('ConcreteHandler2: Unable to handle request');
}
}
}
class ConcreteHandler3 extends Handler {
handle(request) {
if (request.amount > 500) {
console.log(`ConcreteHandler3: Handling request of amount ${request.amount}`);
} else if (this.next) {
console.log('ConcreteHandler3: Unable to handle request, passing it to next handler');
this.next.handle(request);
} else {
console.log('ConcreteHandler3: Unable to handle request');
}
}
}
// 客户端代码
const handler1 = new ConcreteHandler1();
const handler2 = new ConcreteHandler2();
const handler3 = new ConcreteHandler3();
handler1.setNext(handler2);
handler2.setNext(handler3);
const request1 = new Request(50);
const request2 = new Request(200);
const request3 = new Request(1000);
handler1.handle(request1);
handler1.handle(request2);
handler1.handle(request3);
在这个示例中，我们创建了三个具体的处理器类 ConcreteHandler1、ConcreteHandler2 和 ConcreteHandler3，它们分别处理不同金额范围的请求。然后，我们将它们按顺序组合成一个链，并且通过调用 handle 方法来处理请求。当请求到达链中的某个处理器时，如果该处理器无法处理请求，则将请求传递给链中的下一个处理器，直到有一个处理器处理请求为止。
责任链模式的弊端
-
链过长可能影响性能：如果责任链中的处理器过多或者处理器的执行时间过长，可能会影响整体性能，因为每个请求都需要依次通过链中的所有处理器。
-
可能导致请求无法处理：如果责任链中的处理器没有正确配置或者处理器的逻辑错误，可能会导致某些请求无法得到处理，从而影响系统的正确性。
-
调试和维护困难：责任链模式引入了额外的链式结构和逻辑，可能会增加代码的复杂性，从而增加调试和维护的难度。特别是在链中的处理器之间存在依赖关系或者相互交互时，可能会导致逻辑混乱和难以理解。
命令模式 / Command Pattern
命令模式概念
命令模式是一种行为型设计模式，它允许将请求封装成一个对象，从而使得可以将请求参数化、队列化、记录日志以及支持可撤销操作。命令模式的核心思想是将请求的发送者和接收者解耦，使得发送者不需要知道接收者的具体信息，而是通过一个命令对象来执行请求。
命令模式意图
命令模式的意图是将请求封装成一个命令对象，从而使得可以将请求参数化、队列化、记录日志以及支持可撤销操作。
命令模式实际例子
一个典型的例子是遥控器控制器。遥控器上的按钮代表命令对象，每个按钮都执行一个特定的命令，例如开灯、关灯、调节音量等。通过使用命令模式，我们可以将这些命令封装成对象，从而使得遥控器可以执行不同的命令。
命令模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用命令模式：
// 命令接口
class Command {
execute() {
throw new Error('execute() method must be implemented');
}
}
// 具体命令类
class LightOnCommand extends Command {
constructor(light) {
super();
this.light = light;
}
execute() {
this.light.turnOn();
}
}
class LightOffCommand extends Command {
constructor(light) {
super();
this.light = light;
}
execute() {
this.light.turnOff();
}
}
// 接收者类
class Light {
turnOn() {
console.log('Light is on');
}
turnOff() {
console.log('Light is off');
}
}
// 请求者类
class RemoteControl {
constructor() {
this.commands = {};
}
setCommand(name, command) {
this.commands[name] = command;
}
pressButton(name) {
const command = this.commands[name];
if (command) {
command.execute();
} else {
console.log(`No command named ${name}`);
}
}
}
// 客户端代码
const remoteControl = new RemoteControl();
const light = new Light();
const lightOnCommand = new LightOnCommand(light);
const lightOffCommand = new LightOffCommand(light);
remoteControl.setCommand('on', lightOnCommand);
remoteControl.setCommand('off', lightOffCommand);
remoteControl.pressButton('on');
remoteControl.pressButton('off');
在这个示例中，我们创建了两个具体的命令类 LightOnCommand 和 LightOffCommand，它们分别表示打开灯和关闭灯的命令。然后，我们创建了一个遥控器对象 RemoteControl，它可以设置命令并通过按下按钮来执行命令。通过使用命令模式，遥控器可以执行不同的命令，而无需知道命令的具体实现细节。
当我们考虑队列化、记录日志以及支持可撤销时，命令模式可以更加灵活和强大。下面我将给出分别实现这三个功能的代码示例。
队列化
在队列化中，我们可以将命令对象存储在队列中，并在需要时逐个执行。这样可以实现异步执行命令的功能，也可以实现延迟执行命令的效果。
// 创建一个命令队列
const commandQueue = [];
// 添加命令到队列
commandQueue.push(new LightOnCommand(light));
commandQueue.push(new LightOffCommand(light));
// 依次执行队列中的命令
commandQueue.forEach(command => {
command.execute();
});
记录日志
在记录日志中，我们可以在执行命令时记录命令的相关信息，例如命令的类型、执行时间等，从而实现日志记录的功能。
// 具体命令类增加记录日志的功能
class LoggableCommand extends Command {
constructor(command, log) {
super();
this.command = command;
this.log = log;
}
execute() {
console.log(this.log);
this.command.execute();
}
}
// 创建一个记录日志的命令
const loggableCommand = new LoggableCommand(new LightOnCommand(light), 'Light is turned on');
loggableCommand.execute();
支持可撤销
在支持可撤销中，我们可以在命令对象中实现撤销操作，从而可以撤销先前执行的命令。
// 具体命令类增加撤销操作的功能
class UndoableCommand extends Command {
constructor(command) {
super();
this.command = command;
}
execute() {
this.command.execute();
}
undo() {
// 实现撤销操作
}
}
// 创建一个支持可撤销的命令
const undoableCommand = new UndoableCommand(new LightOnCommand(light));
undoableCommand.execute();
undoableCommand.undo();
通过这些扩展，我们可以让命令模式变得更加灵活和强大，从而满足不同的需求。
命令模式的弊端
- 增加类的数量：命令模式引入了额外的命令类，可能会增加类的数量，从而增加代码的复杂性。
- 增加调试和维护成本：由于命令模式引入了额外的命令类，可能会增加调试和维护的成本，特别是在处理多个命令和接收者时。
解释器模式 / Interpreter Pattern
解释器模式概念
解释器模式是一种行为型设计模式，它定义了一种语言的文法，并且建立一个解释器来解释该语言中的句子。通过使用解释器模式，可以将复杂的语言结构分解成简单的语法规则，并且可以在运行时根据语法规则解释和执行语句。
解释器模式意图
解释器模式的意图是定义一种语言的文法，并且建立一个解释器来解释该语言中的句子。通过使用解释器模式，可以将复杂的语言结构分解成简单的语法规则，并且可以在运行时根据语法规则解释和执行语句。
解释器模式实际例子
一个典型的例子是数学表达式求值。在一个数学表达式中，可能会包含加法、减法、乘法、除法等操作符，以及数字和变量等元素。通过使用解释器模式，我们可以定义一种语言的文法来表示数学表达式，并且建立一个解释器来解释和执行这些表达式。
解释器模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用解释器模式来解释和执行数学表达式：
// 抽象表达式类
class Expression {
interpret() {
throw new Error('interpret() method must be implemented');
}
}
// 终端表达式类：数字表达式
class NumberExpression extends Expression {
constructor(value) {
super();
this.value = value;
}
interpret() {
return this.value;
}
}
// 非终端表达式类：加法表达式
class AddExpression extends Expression {
constructor(expression1, expression2) {
super();
this.expression1 = expression1;
this.expression2 = expression2;
}
interpret() {
return this.expression1.interpret() + this.expression2.interpret();
}
}
// 非终端表达式类：减法表达式
class SubtractExpression extends Expression {
constructor(expression1, expression2) {
super();
this.expression1 = expression1;
this.expression2 = expression2;
}
interpret() {
return this.expression1.interpret() - this.expression2.interpret();
}
}
// 客户端代码
const expression1 = new NumberExpression(10);
const expression2 = new NumberExpression(5);
const addExpression = new AddExpression(expression1, expression2);
const subtractExpression = new SubtractExpression(expression1, expression2);
console.log('Result of addition:', addExpression.interpret());
console.log('Result of subtraction:', subtractExpression.interpret());
在这个示例中，我们定义了几种表达式类，包括数字表达式、加法表达式和减法表达式。通过组合这些表达式类，我们可以构建出复杂的数学表达式，并且通过解释器模式来解释和执行这些表达式。
解释器模式的弊端
- 可能会导致类爆炸：当语言的文法规则非常复杂时，可能会导致需要定义大量的表达式类，从而增加了类的数量，使得代码变得复杂和难以维护。
- 执行效率可能较低：解释器模式的执行效率可能较低，特别是在处理复杂的语法结构时，可能会导致性能问题。
迭代器模式 / Iterator Pattern
迭代器模式概念
迭代器模式是一种行为型设计模式，它提供一种顺序访问聚合对象中的各个元素，而不暴露该对象的内部表示。迭代器模式可以让客户端代码以统一的方式访问不同类型的聚合对象，而不必关心它们的内部结构。
迭代器模式意图
迭代器模式的意图是提供一种统一的方式访问聚合对象中的各个元素，而不暴露该对象的内部表示。通过使用迭代器模式，可以让客户端代码以统一的方式访问不同类型的聚合对象。
迭代器模式实际例子
一个典型的例子是遍历数组或集合。在 JavaScript 中，可以使用迭代器模式来遍历数组或集合中的元素，而不必直接访问它们的索引或内部结构。
迭代器模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用迭代器模式来遍历数组中的元素：
// 迭代器接口
class Iterator {
constructor(collection) {
this.collection = collection;
this.index = 0;
}
hasNext() {
return this.index < this.collection.length;
}
next() {
if (this.hasNext()) {
return this.collection[this.index++];
}
return null;
}
}
// 聚合对象类
class Aggregate {
constructor() {
this.collection = [];
}
add(item) {
this.collection.push(item);
}
// 创建迭代器对象
createIterator() {
return new Iterator(this.collection);
}
}
// 客户端代码
const aggregate = new Aggregate();
aggregate.add('Item 1');
aggregate.add('Item 2');
aggregate.add('Item 3');
const iterator = aggregate.createIterator();
while (iterator.hasNext()) {
console.log(iterator.next());
}
在这个示例中，我们定义了一个迭代器类 Iterator，它用于遍历聚合对象中的元素。我们还定义了一个聚合对象类 Aggregate，它包含一个数组作为内部集合，并且提供了添加元素和创建迭代器的方法。通过使用迭代器模式，客户端代码可以以统一的方式遍历不同类型的聚合对象。
迭代器模式的弊端
- 迭代器模式可能导致内存浪费：在某些情况下，迭代器对象可能会存储大量的数据，从而导致内存浪费。特别是在处理大型数据集合时，可能会导致性能问题。
- 迭代器模式可能会导致性能问题：在某些情况下，迭代器模式可能会导致性能问题，特别是在处理大型数据集合时，可能会导致遍历操作的性能下降。
中介者模式 / Mediator Pattern
中介者模式概念
中介者模式是一种行为型设计模式，它允许对象之间通过一个中介者对象来进行通信，而不是直接相互引用。中介者模式的核心思想是将对象之间的通信封装到中介者对象中，从而降低对象之间的耦合度，并且可以更容易地添加新的对象和修改通信方式。
中介者模式意图
中介者模式的意图是将对象之间的通信封装到中介者对象中，从而降低对象之间的耦合度，并且可以更容易地添加新的对象和修改通信方式。
中介者模式实际例子
一个典型的例子是聊天室程序。在一个聊天室中，每个用户都可以发送消息给其他用户，而不需要直接知道其他用户的信息。通过使用中介者模式，可以将用户之间的通信封装到聊天室对象中，从而降低用户之间的耦合度，并且可以更容易地添加新的用户和修改通信方式。
中介者模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用中介者模式来实现一个简单的聊天室程序：
// 中介者类
class ChatRoom {
static showMessage(user, message) {
console.log(new Date().toLocaleTimeString() + ` [${user.getName()}] : ${message}`);
}
}
// 用户类
class User {
constructor(name) {
this.name = name;
}
getName() {
return this.name;
}
sendMessage(message) {
ChatRoom.showMessage(this, message);
}
}
// 客户端代码
const user1 = new User('User1');
const user2 = new User('User2');
user1.sendMessage('Hello, User2!');
user2.sendMessage('Hi, User1!');
在这个示例中，我们创建了一个中介者类 ChatRoom，它有一个静态方法 showMessage 用于显示用户发送的消息。然后，我们创建了两个用户对象 user1 和 user2，它们可以通过调用 sendMessage 方法来发送消息给其他用户。通过使用中介者模式，我们将用户之间的通信封装到 ChatRoom 中，从而降低了用户之间的耦合度。
中介者模式的弊端
- 中介者对象可能变得复杂：当系统中的对象之间的通信变得复杂时，中介者对象可能会变得庞大和复杂，从而增加了维护的难度。
- 可能引入单点故障：中介者模式引入了一个单点故障，如果中介者对象出现问题，可能会影响整个系统的正常运行。
备忘录模式 / Memento Pattern
备忘录模式概念
备忘录模式是一种行为型设计模式，它允许将对象的内部状态保存在外部，以便在稍后的时间点将对象恢复到先前的状态。备忘录模式的核心思想是将对象的状态封装到备忘录对象中，并且可以通过备忘录对象来恢复对象的状态。
备忘录模式意图
备忘录模式的意图是允许在不破坏封装的情况下保存和恢复对象的内部状态。通过使用备忘录模式，可以实现对象的状态保存和恢复功能，并且可以在需要时轻松地将对象恢复到先前的状态。
备忘录模式实际例子
一个典型的例子是文本编辑器的撤销功能。在文本编辑器中，用户可以对文本进行编辑操作，例如添加文本、删除文本等。通过使用备忘录模式，可以在用户执行编辑操作之前保存文本的当前状态，并且可以在用户撤销操作时恢复文本的先前状态。
备忘录模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用备忘录模式实现文本编辑器的撤销功能：
// 备忘录类
class TextEditorMemento {
constructor(content) {
this.content = content;
}
}
// 文本编辑器类
class TextEditor {
constructor() {
this.content = '';
}
addText(text) {
this.content += text;
}
getContent() {
return this.content;
}
save() {
return new TextEditorMemento(this.content);
}
restore(memento) {
this.content = memento.content;
}
}
// 客户端代码
const editor = new TextEditor();
editor.addText('Hello, ');
console.log('Current content:', editor.getContent()); // Output: Hello,
// 保存当前状态
const savedState = editor.save();
editor.addText('world!');
console.log('Current content:', editor.getContent()); // Output: Hello, world!
// 恢复到之前的状态
editor.restore(savedState);
console.log('Current content:', editor.getContent()); // Output: Hello,
在这个示例中，我们定义了 TextEditor 类来表示文本编辑器，它可以添加文本、获取文本内容，并且可以保存和恢复文本的状态。通过使用备忘录模式，我们可以在保存时将当前文本状态保存到备忘录对象中，并且可以在需要时从备忘录对象中恢复文本的状态。
备忘录模式的弊端
- 内存占用可能增加：当备忘录对象保存了大量状态信息时，可能会导致内存占用增加，特别是在保存大型对象的状态时。
- 性能影响：频繁保存和恢复对象状态可能会影响性能，特别是在保存和恢复大型对象状态时。
观察者模式 / Observer Pattern
观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，其所有依赖对象都会收到通知并自动更新。观察者模式也被称为发布-订阅模式。
观察者模式概念
观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。
观察者模式意图
观察者模式的意图是定义一种一对多的依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。
观察者模式实际例子
一个典型的例子是电子商务网站的商品促销活动。当一个商品的价格发生变化时，所有关注该商品的用户都会收到通知并自动更新价格。
观察者模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用观察者模式：
// 观察者接口
class Observer {
update() {
throw new Error('update() method must be implemented');
}
}
// 主题类
class Subject {
constructor() {
this.observers = [];
}
addObserver(observer) {
this.observers.push(observer);
}
removeObserver(observer) {
const index = this.observers.indexOf(observer);
if (index !== -1) {
this.observers.splice(index, 1);
}
}
notify() {
this.observers.forEach(observer => {
observer.update();
});
}
}
// 具体观察者类
class User extends Observer {
constructor(name) {
super();
this.name = name;
}
update() {
console.log(`${this.name} received update notification`);
}
}
// 创建主题对象
const subject = new Subject();
// 创建观察者对象
const user1 = new User('User 1');
const user2 = new User('User 2');
// 将观察者对象添加到主题对象的观察者列表中
subject.addObserver(user1);
subject.addObserver(user2);
// 发布通知
subject.notify();
观察者模式的弊端
- 内存泄漏风险：如果观察者对象没有被正确地移除，可能会导致内存泄漏问题。
- 过度使用可能导致性能问题：如果过度使用观察者模式，可能会导致性能问题，特别是当通知频率较高时。
状态模式 / State Pattern
状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变其行为，使得对象看起来好像修改了其类。状态模式将对象的行为封装在不同的状态对象中，使得对象在不同的状态下具有不同的行为。这样，状态转换时，对象的行为也会相应地发生变化。
概念
状态模式的核心思想是将对象的状态抽象成独立的状态类，每个状态类封装了对象在该状态下的行为。对象在运行时可以根据内部状态的改变自动切换不同的状态类，从而实现不同的行为。
意图
状态模式的意图是允许对象在内部状态改变时改变其行为，使得对象在不同的状态下具有不同的行为。
实际例子
一个典型的例子是电梯系统。电梯可以处于多种状态，如停止、运行、开门、关门等。每种状态下，电梯的行为都是不同的。例如，在运行状态下，电梯可以响应上行、下行、停止等操作，而在开门状态下，电梯可以响应关门操作等。
基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用状态模式：
// 状态接口
class State {
handle() {
throw new Error('handle() method must be implemented');
}
}
// 具体状态类：停止状态
class StopState extends State {
handle() {
console.log('Elevator is stopped');
}
}
// 具体状态类：运行状态
class RunState extends State {
handle() {
console.log('Elevator is running');
}
}
// 具体状态类：开门状态
class OpenState extends State {
handle() {
console.log('Elevator door is open');
}
}
// 上下文类
class Context {
constructor() {
this.state = null;
}
setState(state) {
this.state = state;
}
request() {
this.state.handle();
}
}
// 客户端代码
const context = new Context();
// 设置初始状态为停止状态
context.setState(new StopState());
// 请求
context.request(); // 输出：Elevator is stopped
// 设置状态为运行状态
context.setState(new RunState());
// 请求
context.request(); // 输出：Elevator is running
在这个示例中，我们定义了几种状态类，包括停止状态、运行状态和开门状态。通过设置不同的状态类，我们可以使电梯处于不同的状态下，并且根据不同的状态调用相应的行为。通过使用状态模式，我们可以使电梯的行为更加灵活和易于扩展。
弊端
- 增加了类的数量：使用状态模式会增加类的数量，特别是在有大量状态和状态转换时，可能会导致类的数量激增，使得代码变得复杂。
- 状态之间的转换可能会变得复杂：当状态之间存在复杂的转换关系时，可能会导致状态转换的逻辑变得复杂，从而增加了代码的维护难度。
策略模式 / Strategy Pattern
策略模式概念
策略模式是一种行为型设计模式，它定义了一系列算法，并将每个算法封装成单独的对象，使得它们可以互相替换。策略模式使得算法的变化独立于使用算法的客户端。
策略模式意图
策略模式的意图是定义一系列算法，并将每个算法封装成单独的对象，使得它们可以互相替换。这样可以使得算法的变化独立于使用算法的客户端，从而使得客户端可以根据需要选择不同的算法。
策略模式实际例子
一个典型的例子是排序算法。不同的排序算法可能适用于不同的场景，例如快速排序、冒泡排序、插入排序等。通过使用策略模式，我们可以将每种排序算法封装成单独的对象，并根据需要选择不同的排序算法。
策略模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用策略模式：
// 策略接口
class SortingStrategy {
sort(data) {
throw new Error('sort() method must be implemented');
}
}
// 具体策略类：快速排序算法
class QuickSortStrategy extends SortingStrategy {
sort(data) {
// 实现快速排序算法
console.log('Sorting using QuickSort');
return data.sort((a, b) => a - b);
}
}
// 具体策略类：冒泡排序算法
class BubbleSortStrategy extends SortingStrategy {
sort(data) {
// 实现冒泡排序算法
console.log('Sorting using BubbleSort');
return data.sort((a, b) => a - b);
}
}
// 上下文类
class Sorter {
constructor(strategy) {
this.strategy = strategy;
}
setStrategy(strategy) {
this.strategy = strategy;
}
sort(data) {
return this.strategy.sort(data);
}
}
// 客户端代码
const sorter = new Sorter(new QuickSortStrategy());
const data = [3, 1, 4, 2, 5];
console.log('Original data:', data);
const sortedData = sorter.sort(data);
console.log('Sorted data:', sortedData);
在这个示例中，我们定义了两种具体的排序策略类：快速排序算法和冒泡排序算法。然后我们创建了一个上下文类 Sorter，它接收一个策略对象并且在需要时调用策略对象的方法。客户端代码可以根据需要选择不同的排序算法。
策略模式的弊端
- 增加了对象数量：使用策略模式可能会增加对象的数量，特别是当有多个不同的策略时，可能会导致类的数量增加，使得代码变得复杂。
- 客户端需要了解各种策略：客户端需要了解每种策略的实现细节，从而选择合适的策略，可能会增加了解和维护的成本。
模板方法模式 / Template Method Pattern
模板方法模式概念
模板方法模式是一种行为型设计模式，它定义了一个算法的骨架，将算法中的一些步骤延迟到子类中实现。模板方法模式允许子类在不改变算法结构的情况下重新定义算法中的某些步骤。
模板方法模式意图
模板方法模式的意图是定义一个算法的骨架，并将一些步骤延迟到子类中实现，从而允许子类在不改变算法结构的情况下重新定义算法中的某些步骤。
模板方法模式实际例子
一个典型的例子是制作咖啡和茶。制作咖啡和茶的步骤大致相似，包括煮水、冲泡、倒入杯中、加入调味品等。但是咖啡和茶的具体步骤可能会有所不同。通过使用模板方法模式，我们可以定义一个制作饮料的算法模板，其中包括煮水、冲泡、倒入杯中、加入调味品等步骤，然后让咖啡和茶分别继承该模板，并在子类中实现特定的冲泡步骤。
模板方法模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用模板方法模式：
// 抽象类：制作饮料
class Beverage {
prepare() {
this.boilWater();
this.brew();
this.pourInCup();
this.addCondiments();
}
boilWater() {
console.log('Boiling water');
}
pourInCup() {
console.log('Pouring into cup');
}
// 抽象方法：冲泡
brew() {
throw new Error('brew() method must be implemented');
}
// 抽象方法：加入调味品
addCondiments() {
throw new Error('addCondiments() method must be implemented');
}
}
// 具体类：制作咖啡
class Coffee extends Beverage {
brew() {
console.log('Brewing coffee');
}
addCondiments() {
console.log('Adding sugar and milk');
}
}
// 具体类：制作茶
class Tea extends Beverage {
brew() {
console.log('Steeping the tea');
}
addCondiments() {
console.log('Adding lemon');
}
}
// 客户端代码
const coffee = new Coffee();
coffee.prepare();
const tea = new Tea();
tea.prepare();
在这个示例中，Beverage 是一个抽象类，定义了制作饮料的算法骨架，并声明了两个抽象方法 brew() 和 addCondiments()。Coffee 和 Tea 是具体类，分别实现了 Beverage 中的抽象方法。通过使用模板方法模式，我们可以在不改变算法结构的情况下，让不同的子类实现特定的步骤。
模板方法模式的弊端
- 某些复杂的算法可能会导致类爆炸：如果一个算法非常复杂，可能会导致需要定义大量的具体类，从而增加了类的数量，使得代码变得复杂和难以维护。
- 子类对模板方法的依赖性：如果子类对模板方法中的某些步骤有强依赖性，可能会导致子类难以复用，从而降低了模板方法模式的灵活性。
访问者模式 / Visitor Pattern
访问者模式是一种行为型设计模式，它允许在不修改对象结构的情况下定义对对象结构中元素的新操作。该模式将数据结构和数据操作分离，使得数据结构可以保持稳定，而数据操作可以根据需要灵活变化。
访问者模式概念
访问者模式允许在不修改对象结构的情况下定义对对象结构中元素的新操作。该模式将数据结构和数据操作分离，使得数据结构可以保持稳定，而数据操作可以根据需要灵活变化。
访问者模式意图
访问者模式的意图是在不修改对象结构的情况下定义对对象结构中元素的新操作。通过使用访问者模式，可以使得对象结构可以保持稳定，而数据操作可以根据需要灵活变化。
访问者模式实际例子
一个典型的例子是对文件系统进行遍历和操作。文件系统可以看作是一个复杂的对象结构，而文件操作可以看作是对该对象结构中元素的操作。通过使用访问者模式，我们可以定义不同的访问者来执行不同的操作，例如计算文件系统的总大小、统计文件数量等。
访问者模式基于 JavaScript 的代码示例
下面是一个简单的 JavaScript 示例，演示了如何使用访问者模式：
// 访问者接口
class Visitor {
visitFile(file) {
throw new Error('visitFile() method must be implemented');
}
visitDirectory(directory) {
throw new Error('visitDirectory() method must be implemented');
}
}
// 文件类
class File {
constructor(name, size) {
this.name = name;
this.size = size;
}
accept(visitor) {
visitor.visitFile(this);
}
}
// 目录类
class Directory {
constructor(name, children) {
this.name = name;
this.children = children;
}
accept(visitor) {
visitor.visitDirectory(this);
this.children.forEach(child => {
child.accept(visitor);
});
}
}
// 具体访问者类：计算文件总大小
class TotalSizeVisitor extends Visitor {
constructor() {
super();
this.totalSize = 0;
}
visitFile(file) {
this.totalSize += file.size;
}
visitDirectory(directory) {
// Do nothing for directory
}
getTotalSize() {
return this.totalSize;
}
}
// 创建文件和目录
const file1 = new File('file1.txt', 100);
const file2 = new File('file2.txt', 200);
const directory = new Directory('dir', [file1, file2]);
// 创建访问者
const totalSizeVisitor = new TotalSizeVisitor();
// 访问文件和目录
directory.accept(totalSizeVisitor);
// 输出文件总大小
console.log('Total size:', totalSizeVisitor.getTotalSize());
访问者模式的弊端
- 增加了对象结构的复杂性：访问者模式会将对象结构和操作分离，使得对象结构变得更加复杂，增加了系统的理解和维护成本。
- 不适用于稳定的对象结构：如果对象结构稳定且不经常变化，可能会导致访问者模式的使用变得不必要。
扫一扫
2284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
