每位开发者都应该知道的7种 Node.js 设计模式

// 复杂模块
class ComplexModule {
  initialize() {
    // 复杂的初始化逻辑...
  }
  operation1() {
    // 复杂操作 1
  }
  operation2() {
    // 复杂操作 2
  }
}
// 客户端代码
const complexModule = new ComplexModule();
complexModule.initialize();
complexModule.operation1();
complexModule.operation2();

// 在复杂模块中使用门面模式
class ModuleFacade {
  constructor() {
    this.complexModule = new ComplexModule();
  }
  performOperations() {
    this.complexModule.initialize();
    this.complexModule.operation1();
    this.complexModule.operation2();
  }
}
// 客户端代码
const moduleFacade = new ModuleFacade();
moduleFacade.performOperations();

class ConfigManager {
  constructor() {
    this.databaseConfig = { /* 数据库配置 */ };
    this.apiKey = "your_api_key";
    // 其他应用配置
  }

  static getInstance() {
    if (!this.instance) {
      this.instance = new ConfigManager();
    }
    return this.instance;
  }

  getDatabaseConfig() {
    return this.databaseConfig;
  }

  getApiKey() {
    return this.apiKey;
  }
  // 其他获取配置的方法
}

// 客户端
const configManager = ConfigManager.getInstance();

// 访问配置
const databaseConfig = configManager.getDatabaseConfig();
const apiKey = configManager.getApiKey();

class OldSystem {
  request() {
    return "Old System Request";
  }
}

class NewSystem {
  newRequest() {
    return "New System Request";
  }
}

class Adapter {
  constructor(newSystem) {
    this.newSystem = newSystem;
  }

  request() {
    return this.newSystem.newRequest();
  }
}

// 老系统的使用
const oldSystem = new OldSystem();
console.log(oldSystem.request()); // 输出：Old System Request

// 通过适配器使用新系统
const newSystem = new NewSystem();
const adapter = new Adapter(newSystem);
console.log(adapter.request()); // 输出: New System Request

class UserBuilder {
  constructor(name) {
    this.name = name;
    this.email = null;
    this.address = null;
  }

  withEmail(email) {
    this.email = email;
    return this; // 通过返回 this 实现方法的链式调用
  }

  withAddress(address) {
    this.address = address;
    return this;
  }

  build() {
    // 验证和构造用户对象
    const user = new User({
      name: this.name,
      email: this.email,
      address: this.address,
    });
    return user;
  }
}

// 客户端代码
const user1 = new UserBuilder('John')
  .withEmail('john@example.com')
  .withAddress('123 Main St.')
  .build();

console.log(user1); // 打印完整的用户对象的值

// Shape 接口
class Shape {
  draw() {}
}

// Shape 接口的具体实现
class Circle extends Shape {
  draw() {
    console.log("Drawing Circle");
  }
}
class Square extends Shape {
  draw() {
    console.log("Drawing Square");
  }
}
class Triangle extends Shape {
  draw() {
    console.log("Drawing Triangle");
  }
}

// ShapeFactory 类负责创 Shape 的实例
class ShapeFactory {
  createShape(type) {
    switch (type) {
      case 'circle':
        return new Circle();
      case 'square':
        return new Square();
      case 'triangle':
        return new Triangle();
      default:
        throw new Error('Invalid shape type');
    }
  }
}

// 客户端代码使用 ShapeFactory 来创建 Shape
const shapeFactory = new ShapeFactory();
const circle = shapeFactory.createShape('circle');
circle.draw(); // 输出：画圆
const square = shapeFactory.createShape('square');
square.draw(); // 输出：画正方形
const triangle = shapeFactory.createShape('triangle');
triangle.draw(); // 输出：画三角形

// 原型对象
const animalPrototype = {
  type: 'unknown',
  makeSound: function () {
    console.log('Some generic sound');
  },
  clone: function () {
    return Object.create(this); // 使用 Object.create() 进行克隆
  },
};

// 基于原型的自定义实例
const dog = animalPrototype.clone();
dog.type = 'Dog';
dog.makeSound = function () {
  console.log('Woof!');
};

const cat = animalPrototype.clone();
cat.type = 'Cat';
cat.makeSound = function () {
  console.log('Meow!');
};

// 使用自定义实例的客户端代码
dog.makeSound(); // 输出：Woof!
cat.makeSound(); // 输出：Meow!

const target = {
  name: 'Alice',
  sayHello() {
    console.log(Hello, my name is ${this.name} );
  },
};
const handler = {
  get(target, prop, receiver) {
    console.log(Property ${prop} accessed );
    return Reflect.get(target, prop, receiver);
  },
  set(target, prop, value, receiver) {
    console.log(Property ${prop} set to ${value} );
    return Reflect.set(target, prop, value, receiver);
  },
};
const proxy = new Proxy(target, handler);
proxy.name; // 输出：访问属性名
proxy.sayHello(); // 输出：访问属性方法 sayHello
                  //        Hello, my name is Alice
proxy.name = 'Bob'; // 输出：属性名设置为 Bob