Deno 设计模式

在软件开发中，设计模式是解决常见问题的模板。它们帮助开发者以一种可重用和可维护的方式解决特定的问题。本章将介绍几种适用于 Deno 的设计模式，并提供实际的例子来展示如何在项目中应用这些模式。

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。这对于需要全局访问的资源（如数据库连接或配置对象）非常有用。

实现方式

// www.javascriptcn.com code example
class Config {
    static #instance = null;

    constructor() {
        if (!Config.#instance) {
            this.configData = {};
            Config.#instance = this;
        } else {
            throw new Error("不能创建新的实例");
        }
    }

    static getInstance() {
        if (!Config.#instance) {
            Config.#instance = new Config();
        }
        return Config.#instance;
    }

    set(key, value) {
        this.configData[key] = value;
    }

    get(key) {
        return this.configData[key];
    }
}

// 使用示例
const config = Config.getInstance();
config.set('host', 'localhost');
console.log(config.get('host')); // 输出 "localhost"

观察者模式

观察者模式允许对象订阅其他对象的状态变化。当被观察的对象状态改变时，它会通知所有订阅者。

实现方式

// www.javascriptcn.com code example
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(`Received data: ${data}`);
    }
}

// 使用示例
const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();

subject.subscribe(observer1);
subject.subscribe(observer2);

subject.notify("Hello World!"); // 输出 "Received data: Hello World!" 两次

工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。当一个类不知道它所必须创建的对象的类的时候，当一个类希望由它的子类来指定它所创建的对象的时候，或者该类将它的子类与其创建的实现分离时，可以使用工厂模式。

实现方式

// www.javascriptcn.com code example
class ProductFactory {
    createProduct(type) {
        switch (type) {
            case 'A':
                return new ProductA();
            case 'B':
                return new ProductB();
            default:
                throw new Error("未知类型");
        }
    }
}

class ProductA {
    getName() {
        return "Product A";
    }
}

class ProductB {
    getName() {
        return "Product B";
    }
}

// 使用示例
const factory = new ProductFactory();
const productA = factory.createProduct('A');
console.log(productA.getName()); // 输出 "Product A"

const productB = factory.createProduct('B');
console.log(productB.getName()); // 输出 "Product B"

抽象工厂模式

抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而无需指定它们具体的类。这个模式使得我们可以很容易地替换产品家族，同时保持客户端代码不变。

实现方式

// www.javascriptcn.com code example
class AbstractFactory {
    createProductA() {}
    createProductB() {}
}

class ConcreteFactory1 extends AbstractFactory {
    createProductA() {
        return new ProductA1();
    }

    createProductB() {
        return new ProductB1();
    }
}

class ConcreteFactory2 extends AbstractFactory {
    createProductA() {
        return new ProductA2();
    }

    createProductB() {
        return new ProductB2();
    }
}

class ProductA1 {
    getName() {
        return "Product A1";
    }
}

class ProductA2 {
    getName() {
        return "Product A2";
    }
}

class ProductB1 {
    getName() {
        return "Product B1";
    }
}

class ProductB2 {
    getName() {
        return "Product B2";
    }
}

// 使用示例
const factory1 = new ConcreteFactory1();
const productA1 = factory1.createProductA();
console.log(productA1.getName()); // 输出 "Product A1"

const productB1 = factory1.createProductB();
console.log(productB1.getName()); // 输出 "Product B1"

const factory2 = new ConcreteFactory2();
const productA2 = factory2.createProductA();
console.log(productA2.getName()); // 输出 "Product A2"

const productB2 = factory2.createProductB();
console.log(productB2.getName()); // 输出 "Product B2"

以上几个例子展示了如何在 Deno 中使用一些常见的设计模式。理解并正确使用这些模式可以帮助我们构建更加灵活、可扩展和易于维护的应用程序。