亲们都用Nodejs写过神马设计模式呢？

亲们都用Nodejs写过神马设计模式呢？

赶脚用JS写模式好难：（

3 回复

当然可以！以下是一个关于在Node.js中实现几种常见的设计模式的示例。这些设计模式包括单例模式、工厂模式和观察者模式。希望这些示例能够帮助你更好地理解和应用设计模式。

单例模式

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

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

    doSomething() {
        console.log('Doing something...');
    }
}

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

console.log(instance1 === instance2); // 输出: true
instance1.doSomething(); // 输出: Doing something...

工厂模式

工厂模式用于创建对象，而无需指定具体的类。

class Product {
    constructor(name) {
        this.name = name;
    }

    getName() {
        return this.name;
    }
}

class ProductFactory {
    createProduct(name) {
        return new Product(name);
    }
}

const factory = new ProductFactory();
const product1 = factory.createProduct('Product 1');
const product2 = factory.createProduct('Product 2');

console.log(product1.getName()); // 输出: Product 1
console.log(product2.getName()); // 输出: Product 2

观察者模式

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知。

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(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.addObserver(observer1);
subject.addObserver(observer2);

subject.notify('Hello World'); // 输出: Received data: Hello World
subject.notify('Another message'); // 输出: Received data: Another message

这些示例展示了如何在Node.js中使用不同的设计模式。通过这些模式，你可以更好地组织和管理代码，提高代码的可维护性和复用性。希望这些示例对你有所帮助！


写过工厂，单例，观察者，装饰者，策略。就用过这几个

当然，使用Node.js编写设计模式是非常常见且有用的。以下是一些常见的设计模式及其在Node.js中的实现示例。

单例模式 (Singleton Pattern)

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

class Database {
    constructor(host, user, password) {
        if (!Database.instance) {
            this.host = host;
            this.user = user;
            this.password = password;
            Database.instance = this;
        }
        return Database.instance;
    }

    connect() {
        console.log(`Connected to database at ${this.host}`);
    }
}

const db1 = new Database('localhost', 'user', 'password');
const db2 = new Database('remotehost', 'admin', 'admin');

db1.connect(); // 输出: Connected to database at localhost
db2.connect(); // 输出: Connected to database at localhost

工厂模式 (Factory Pattern)

工厂模式用于创建对象，而不需要指定具体的类。

class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
    }

    getName() {
        return this.name;
    }
}

class Admin extends User {
    constructor(name, email) {
        super(name, email);
    }

    getRole() {
        return "Admin";
    }
}

function createUser(type, name, email) {
    switch (type) {
        case 'admin':
            return new Admin(name, email);
        default:
            return new User(name, email);
    }
}

const adminUser = createUser('admin', 'Alice', 'alice@example.com');
console.log(adminUser.getName()); // 输出: Alice
console.log(adminUser.getRole()); // 输出: Admin

观察者模式 (Observer Pattern)

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

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

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

    removeObserver(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.addObserver(observer1);
subject.addObserver(observer2);

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

subject.removeObserver(observer1);
subject.notify("Hello Node.js"); // 输出: Received data: Hello Node.js

希望这些示例对你有所帮助！如果你有任何问题或需要更详细的解释，请随时提问。

回到顶部