用js搞清策略模式和责任链模式的区别

策略模式和责任链模式都是常用的设计模式，它们的目的都是为了解耦和提高代码的可维护性。但是，它们的应用场景不同，下面对它们进行详细的比较和介绍。

策略模式

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同。它可以让算法的变化独立于使用它的客户端（也就是上下文），从而可以在不修改客户端的情况下，增加或替换算法。策略模式主要包含三个角色：上下文（Context）、策略（Strategy）和具体策略（ConcreteStrategy）。下面通过一个简单的示例来说明策略模式的应用。

策略模式是一种行为型设计模式，它定义了一系列算法，把它们一个个封装起来，并且使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。策略模式的核心是将算法的实现和调用分离开来，使得算法的实现可以独立于使用它的客户端。这样，算法的变化不会对客户端代码产生影响。在策略模式中，客户端通过调用Context类中的某个方法来使用其中封装的算法。Context类中的方法会根据具体的策略对象来调用相应的算法。下面是一个使用策略模式的例子，假设有一个计算器，可以根据用户的输入计算每个数字的平方和立方，最后将所有结果相加。

// 定义策略类
class SquareStrategy {
  calculate(num) {
    return num * num;
  }
}
class CubeStrategy {
  calculate(num) {
    return num * num * num;
  }
}
// 定义Context类
class Calculator {
  // 可以通过构造函数或者 setStratey 设置不同策略类
  constructor(strategy) {
    this.strategy = strategy;
  }
  setStrategy(strategy) {
    this.strategy = strategy;
  }

  // 计算类，调用策略类进行最终结果的计算
  calculate(nums) {
    let result = 0;
    for (let num of nums) {
      result += this.strategy.calculate(num);
    }
    return result;
  }
}

// 使用策略模式
const calculator = new Calculator(new SquareStrategy());
console.log(calculator.calculate([1, 2, 3])); // 输出14
calculator.setStrategy(new CubeStrategy());
console.log(calculator.calculate([1, 2, 3])); // 输出36

责任链模式

责任链模式也是一种行为型设计模式，它通过一条链来组织多个处理器，每个处理器都可以处理请求，如果当前处理器不能处理请求，则将请求传递给下一个处理器，直到请求被处理为止。责任链模式让请求的发送者和接收者都没有明确的关系，而是通过一条链来连接起来。责任链模式的核心是将多个处理器组织成一条链，每个处理器都可以处理请求，并且知道下一个处理器是谁。在处理请求的过程中，如果当前处理器不能处理请求，则将请求传递给下一个处理器，直到有一个处理器能够处理请求为止。在责任链模式中，每个处理器都只需要关注自己能够处理的请求，而不需要关注其它请求。下面是一个使用责任链模式的例子，假设有一个请假系统，需要根据请假天数来决定是否批准请假。

// 定义处理器类
class Handler {
  constructor(name, nextHandler) {
    this.name = name;
    this.nextHandler = nextHandler;
  }
  handleRequest(days) {
    if (this.canHandleRequest(days)) {
      console.log(`${this.name} 批准了 ${days} 天的请假`);
    } else if (this.nextHandler) {
      this.nextHandler.handleRequest(days);
    } else {
      console.log(`没有处理器能够处理 ${days} 天的请假`);
    }
  }
  canHandleRequest(days) {
    throw new Error('子类必须实现 canHandleRequest 方法');
  }
}

class ManagerHandler extends Handler {
  canHandleRequest(days) {
    return days <= 3;
  }
}
class DirectorHandler extends Handler {
  canHandleRequest(days) {
    return days <= 7;
  }
}
class CEOHandler extends Handler {
  canHandleRequest(days) {
    return days <= 30;
  }
}

// 使用责任链模式
    const ceo = new CEOHandler('CEO');
    const director = new DirectorHandler('主管', ceo);
    const manager = new ManagerHandler('经理', director);
    manager.handleRequest(2); // 输出：经理 批准了 5 天的请假
    manager.handleRequest(5); // 输出：主管 批准了 5 天的请假
    manager.handleRequest(20); // 输出：CEO 批准了 20 天的请假

责任链模式的第二种实现可以用数组，相比于递归，数组方法更易理解，复杂度更低。

    class CommandHandler {
      constructor() {
        this.handlers = [];
      }

      addHandler(handler) {
        this.handlers.push(handler);
      }

      handle(command) {
        for (let i = 0; i < this.handlers.length; i++) {
          if (this.handlers[i].canHandle(command)) {
            return this.handlers[i].handle(command);
          }
        }
        throw new Error('No handler found for command: ' + command);
      }
    }

    class LoginHandler {
      canHandle(command) {
        return command === 'login';
      }

      handle(command) {
        // 处理登录命令
        console.log('处理：', command);
      }
    }

    class ChatHandler {
      canHandle(command) {
        return command === 'chat';
      }

      handle(command) {
        // 处理聊天命令
        console.log('处理：', command);
      }
    }

    class BroadcastHandler {
      canHandle(command) {
        return command === 'broadcast';
      }

      handle(command) {
        // 处理广播命令
        console.log('处理：', command);
      }
    }

    const handler = new CommandHandler();
    handler.addHandler(new LoginHandler());
    handler.addHandler(new ChatHandler());
    handler.addHandler(new BroadcastHandler());

    handler.handle('login'); // 处理登录命令
    handler.handle('chat'); // 处理聊天命令
    handler.handle('broadcast'); // 处理广播命令
   

策略模式和责任链模式的区别策略模式和责任链模式都是行为型设计模式，它们的目的都是为了解耦和提高代码的可维护性，但是它们的应用场景和解决问题的方式不同。策略模式适用于多个算法可以替换的情况，它将算法的实现和调用分离开来，使得算法的变化不会对客户端代码产生影响。而责任链模式适用于处理器之间存在一定的逻辑关系，处理器之间可以组成一条链，每个处理器都可以处理请求，如果当前处理器不能处理请求，则将请求传递给下一个处理器，直到请求被处理为止。在策略模式中，客户端需要知道每个策略对象的存在，并且需要选择一个合适的策略对象来处理数据。而在责任链模式中，客户端不需要知道每个处理器的存在，它只需要将请求发送给责任链的第一个处理器，然后等待处理结果即可。在实现上，策略模式通常使用组合来组织策略对象，客户端需要显式地创建和设置策略对象。而责任链模式通常使用继承来组织处理器，处理器之间的关系在继承关系中确定。客户端只需要知道责任链的第一个处理器即可。总之，策略模式和责任链模式都是非常有用的设计模式，它们都可以帮助我们解耦和提高代码的可维护性，但是在不同的场景下使用不同的模式才能发挥最大的作用。