Node.js中常用设计模式的使用方法总结

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

  // Your code here
}

module.exports = Singleton;

class Car {
  constructor(name) {
    this.name = name;
  }
  drive() {
    console.log(`Driving ${this.name}`);
  }
}

class CarFactory {
  static create(name) {
    return new Car(name);
  }
}

const car1 = CarFactory.create("BMW");
const car2 = CarFactory.create("Audi");

car1.drive(); // Driving BMW
car2.drive(); // Driving Audi

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

  subscribe(fn) {
    this.observers.push(fn);
  }

  unsubscribe(fn) {
    this.observers = this.observers.filter(subscriber => subscriber !== fn);
  }

  notify(data) {
    this.observers.forEach(observer => observer(data));
  }
}

const eventObserver = new EventObserver();

eventObserver.subscribe(data => console.log(`Subscribed to ${data}`));
eventObserver.notify("some data");

class UserService {
  constructor(database) {
    this.database = database;
  }

  getUser(id) {
    return this.database.query(`SELECT * FROM users WHERE id = ${id}`);
  }
}

module.exports = UserService;

const fs = require('fs').promises;

function readFile(filePath) {
  return fs.readFile(filePath, 'utf8');
}

readFile('example.txt')
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });

const fs = require('fs');

// 异步读取文件
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// 同步读取文件
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);

// 写入文件
fs.writeFile('file.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('文件已写入');
});

// 模块定义
const myModule = (function () {
  // 私有成员
  const privateVar = 'Hello, World!';

  function privateMethod() {
    console.log(privateVar);
  }

  // 公有成员
  return {
    publicMethod: function () {
      privateMethod();
    },
    publicVar: 'I am public'
  };
})();

// 使用模块
myModule.publicMethod();  // 输出 'Hello, World!'
console.log(myModule.publicVar); // 输出 'I am public'

function fetchData(callback) {
  // 模拟异步数据获取
  setTimeout(() => {
    const data = 'Hello, World!';
    callback(null, data); // 第一个参数为错误对象，第二个参数为返回的数据
  }, 2000);
}

function processData(err, data) {
  if (err) {
    console.error('出错了：', err);
    return;
  }
  console.log('处理数据：', data);
}

fetchData(processData);

// 中间件函数1
function middleware1(req, res, next) {
  console.log('执行中间件1');
  // 在这里可以对 req 和 res 进行处理
  next(); // 调用 next() 将控制权传递给下一个中间件
}

// 中间件函数2
function middleware2(req, res, next) {
  console.log('执行中间件2');
  // 在这里可以对 req 和 res 进行处理
  next(); // 调用 next() 将控制权传递给下一个中间件
}

// 最终处理函数
function finalHandler(req, res) {
  console.log('执行最终处理函数');
  // 在这里进行最终的请求处理和响应
  res.end('Hello, World!');
}

// 使用中间件
function handleRequest(req, res) {
  middleware1(req, res, () => {
    middleware2(req, res, () => {
      finalHandler(req, res);
    });
  });
}

// 创建服务器并处理请求
const http = require('http');
const server = http.createServer(handleRequest);

server.listen(3000, 'localhost', () => {
  console.log('服务器已启动');
});

// 用户服务模块
class UserService {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
  }

  getUsers() {
    return this.users;
  }
}

// 用户控制器模块（依赖于用户服务模块）
class UserController {
  constructor(userService) {
    this.userService = userService;
  }

  addUser(user) {
    this.userService.addUser(user);
  }

  getUsers() {
    return this.userService.getUsers();
  }
}

// 使用依赖注入创建用户控制器实例
const userService = new UserService();
const userController = new UserController(userService);

// 在用户控制器中添加用户并获取用户列表
userController.addUser('John');
userController.addUser('Mary');
console.log(userController.getUsers()); // 输出：['John', 'Mary']

// 使用 Promise 封装异步函数
function getUserById(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const user = { id, name: 'John' };
      resolve(user);
    }, 1000);
  });
}

// 调用异步函数并使用 Promise 链式调用处理结果
getUserById(1)
  .then(user => {
    console.log(user);
    return getUserById(2);
  })
  .then(user => {
    console.log(user);
  })
  .catch(err => {
    console.error(err);
  });