浅谈几种js设计模式

JavaScript设计模式是开发中常用的一种解决方案，它们帮助开发者以一种更结构化、更易维护的方式编写代码。本文将深入介绍几种常见的JavaScript设计模式，包括单例模式、工厂模式、观察者模式和策略模式。

一、单例模式（Singleton Pattern）

单例模式是一种创建型模式，确保一个类只有一个实例，并提供一个全局访问点。

实现方式

复制代码

class Singleton {
    constructor() {
        if (!Singleton.instance) {
            Singleton.instance = this;
        }
        return Singleton.instance;
    }

    someMethod() {
        console.log('Hello, Singleton!');
    }
}

const instance1 = new Singleton();
const instance2 = new Singleton();

console.log(instance1 === instance2); // true
instance1.someMethod(); // Hello, Singleton!

使用场景

需要确保全局只有一个实例的情况，例如全局配置对象、数据库连接等。

二、工厂模式（Factory Pattern）

工厂模式是一种创建型模式，通过工厂方法创建对象，而不是直接使用new操作符。

实现方式

复制代码

class Car {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`${this.model} is driving.`);
    }
}

class CarFactory {
    static createCar(model) {
        return new Car(model);
    }
}

const car1 = CarFactory.createCar('Toyota');
const car2 = CarFactory.createCar('Honda');

car1.drive(); // Toyota is driving.
car2.drive(); // Honda is driving.

使用场景

当对象的创建逻辑复杂或需要根据条件创建不同类型的对象时使用工厂模式。

三、观察者模式（Observer Pattern）

观察者模式是一种行为型模式，定义了对象间的一对多依赖，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。

实现方式

复制代码

class Subject {
    constructor() {
        this.observers = [];
    }

    addObserver(observer) {
        this.observers.push(observer);
    }

    removeObserver(observer) {
        this.observers = this.observers.filter(obs => obs !== observer);
    }

    notifyObservers() {
        this.observers.forEach(observer => observer.update());
    }
}

class Observer {
    update() {
        console.log('Observer notified.');
    }
}

const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notifyObservers();
// Observer notified.
// Observer notified.

使用场景

用于实现事件处理机制，如事件监听器、发布-订阅模式等。

四、策略模式（Strategy Pattern）

策略模式是一种行为型模式，定义了一系列算法，并将每个算法封装起来，使它们可以互换使用。

实现方式

复制代码

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

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

    executeStrategy(data) {
        return this.strategy.execute(data);
    }
}

class ConcreteStrategyA {
    execute(data) {
        return `Strategy A with data: ${data}`;
    }
}

class ConcreteStrategyB {
    execute(data) {
        return `Strategy B with data: ${data}`;
    }
}

const context = new StrategyContext(new ConcreteStrategyA());
console.log(context.executeStrategy('test')); // Strategy A with data: test

context.setStrategy(new ConcreteStrategyB());
console.log(context.executeStrategy('test')); // Strategy B with data: test

使用场景

当需要在运行时切换算法或行为时使用策略模式，例如不同的排序算法、不同的支付方式等。