javascript 常见设计模式

MarkHD

于 2024-07-05 11:09:14 发布

阅读量1k

点赞数 31

文章标签： javascript 设计模式开发语言

本文链接：https://blog.csdn.net/gapapp/article/details/140202940

版权

JavaScript 中常见的设计模式帮助开发者解决代码组织、复用和扩展的问题。以下是一些在JavaScript开发中常见的设计模式：

单例模式（Singleton Pattern）：确保一个类仅有一个实例，并提供一个全局访问点。在JavaScript中，这通常通过创建一个对象并在需要时返回这个对象的引用来实现。
工厂模式（Factory Pattern）：定义一个创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。在JavaScript中，这通常通过函数实现，该函数根据传入的参数返回不同类型的对象。
建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。在JavaScript中，这可以通过一个构造器或配置函数来实现，该函数接受多个参数来逐步构建复杂对象。
原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。JavaScript本身是基于原型的语言，因此这个模式在JavaScript中非常自然。
观察者模式（Observer Pattern）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在JavaScript中，这可以通过事件监听和发布/订阅模式来实现。
策略模式（Strategy Pattern）：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。此模式让算法的变化独立于使用算法的客户。在JavaScript中，可以通过函数或对象字面量来实现策略。
装饰者模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式相比生成子类更为灵活。在JavaScript中，这可以通过高阶函数（接收函数作为参数或返回一个函数的函数）或代理模式（Proxy）来实现。
适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口，适配器模式让原本接口不兼容的类可以一起工作。在JavaScript中，这可以通过函数或对象来实现，这些函数或对象包装了不兼容的接口并提供一个统一的接口。
模块模式（Module Pattern）：提供了一种封装私有变量和函数的方法，但同时又提供了一个公共的接口来访问这些私有成员。在JavaScript中，这通常通过函数和闭包来实现。
代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。在JavaScript中，ES6引入了Proxy对象，它允许你定义基本操作的自定义行为（如属性查找、赋值、枚举、函数调用等）。

这些设计模式是软件开发中宝贵的工具，它们帮助开发者编写更加清晰、灵活和可维护的代码。然而，并非每个项目都需要使用所有这些模式；重要的是根据具体需求选择最合适的模式。

当然，我可以为你提供一个简单的示例来展示如何在JavaScript中使用一些常见的设计模式。这里，我将以单例模式、工厂模式和策略模式为例来补充代码。

单例模式（Singleton Pattern）

class Singleton {
    static instance = null;

    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }
        Singleton.instance = this;
        // 初始化代码
        this.data = "I am the singleton instance";
    }

    getData() {
        return this.data;
    }
}

// 使用
const instance1 = new Singleton();
const instance2 = new Singleton();

console.log(instance1 === instance2); // 输出: true
console.log(instance1.getData()); // 输出: I am the singleton instance

工厂模式（Factory Pattern）

function createLogger(type) {
    switch (type) {
        case 'console':
            return new ConsoleLogger();
        case 'file':
            return new FileLogger();
        default:
            throw new Error('Unknown logger type');
    }
}

class Logger {
    log(message) {
        console.error('Abstract method "log" called');
    }
}

class ConsoleLogger extends Logger {
    log(message) {
        console.log(message);
    }
}

class FileLogger extends Logger {
    log(message) {
        console.log(`Logging to file: ${message}`);
    }
}

// 使用
const consoleLogger = createLogger('console');
const fileLogger = createLogger('file');

consoleLogger.log('This is a console log');
fileLogger.log('This is a file log');

策略模式（Strategy Pattern）

class Strategy {
    execute(num1, num2) {
        console.error('Abstract method "execute" called');
    }
}

class AddStrategy extends Strategy {
    execute(num1, num2) {
        return num1 + num2;
    }
}

class SubtractStrategy extends Strategy {
    execute(num1, num2) {
        return num1 - num2;
    }
}

class Context {
    constructor(strategy) {
        this.strategy = strategy;
    }

    executeStrategy(num1, num2) {
        return this.strategy.execute(num1, num2);
    }

    changeStrategy(strategy) {
        this.strategy = strategy;
    }
}

// 使用
const context = new Context(new AddStrategy());
console.log(context.executeStrategy(5, 3)); // 输出: 8

context.changeStrategy(new SubtractStrategy());
console.log(context.executeStrategy(5, 3)); // 输出: 2