strategy design pattern，定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。

最常见的应用场景是拿来避免冗长的 if-else 或 switch 分支判断，主要是将 if else 的判断逻辑下放或存放在 Map 中以键值对的方式替代 if else，其中 Map 的 key 对应判断条件， value 则封装成策略替代进入判断条件的业务。

  1. // 策略接口声明了某个算法各个不同版本间所共有的操作。上下文会使用该接口来
  2. // 调用有具体策略定义的算法。
  3. interface Strategy is
  4.     method execute(a, b)
  6. // 具体策略会在遵循策略基础接口的情况下实现算法。该接口实现了它们在上下文
  7. // 中的互换性。
  8. class ConcreteStrategyAdd implements Strategy is
  9.     method execute(a, b) is
  10.         return a + b
  12. class ConcreteStrategySubtract implements Strategy is
  13.     method execute(a, b) is
  14.         return a - b
  16. class ConcreteStrategyMultiply implements Strategy is
  17.     method execute(a, b) is
  18.         return a * b
  20. // 上下文定义了客户端关注的接口。
  21. class Context is
  22.     // 上下文会维护指向某个策略对象的引用。上下文不知晓策略的具体类。上下
  23.     // 文必须通过策略接口来与所有策略进行交互。
  24.     private strategy: Strategy
  26.     // 上下文通常会通过构造函数来接收策略对象，同时还提供设置器以便在运行
  27.     // 时切换策略。
  28.     method setStrategy(Strategy strategy) is
  29.         this.strategy = strategy
  31.     // 上下文会将一些工作委派给策略对象，而不是自行实现不同版本的算法。
  32.     method executeStrategy(int a, int b) is
  33.         return strategy.execute(a, b)
  36. // 客户端代码会选择具体策略并将其传递给上下文。客户端必须知晓策略之间的差
  37. // 异，才能做出正确的选择。
  38. class ExampleApplication is
  39.     method main() is
  41.         创建上下文对象。
  43.         读取第一个数。
  44.         读取最后一个数。
  45.         从用户输入中读取期望进行的行为。
  47.         if (action == addition) then
  48.             context.setStrategy(new ConcreteStrategyAdd())
  50.         if (action == subtraction) then
  51.             context.setStrategy(new ConcreteStrategySubtract())
  53.         if (action == multiplication) then
  54.             context.setStrategy(new ConcreteStrategyMultiply())
  56.         result = context.executeStrategy(First number, Second number)
  58.         打印结果。
  1. /**
  2.  * The Context defines the interface of interest to clients.
  3.  */
  4. class Context {
  5.     /**
  6.      * @type {Strategy} The Context maintains a reference to one of the Strategy
  7.      * objects. The Context does not know the concrete class of a strategy. It
  8.      * should work with all strategies via the Strategy interface.
  9.      */
  10.     private strategy: Strategy;
  12.     /**
  13.      * Usually, the Context accepts a strategy through the constructor, but also
  14.      * provides a setter to change it at runtime.
  15.      */
  16.     constructor(strategy: Strategy) {
  17.         this.strategy = strategy;
  18.     }
  20.     /**
  21.      * Usually, the Context allows replacing a Strategy object at runtime.
  22.      */
  23.     public setStrategy(strategy: Strategy) {
  24.         this.strategy = strategy;
  25.     }
  27.     /**
  28.      * The Context delegates some work to the Strategy object instead of
  29.      * implementing multiple versions of the algorithm on its own.
  30.      */
  31.     public doSomeBusinessLogic(): void {
  32.         // ...
  34.         console.log('Context: Sorting data using the strategy (not sure how it\'ll do it)');
  35.         const result = this.strategy.doAlgorithm(['a', 'b', 'c', 'd', 'e']);
  36.         console.log(result.join(','));
  38.         // ...
  39.     }
  40. }
  42. /**
  43.  * The Strategy interface declares operations common to all supported versions
  44.  * of some algorithm.
  45.  *
  46.  * The Context uses this interface to call the algorithm defined by Concrete
  47.  * Strategies.
  48.  */
  49. interface Strategy {
  50.     doAlgorithm(data: string[]): string[];
  51. }
  53. /**
  54.  * Concrete Strategies implement the algorithm while following the base Strategy
  55.  * interface. The interface makes them interchangeable in the Context.
  56.  */
  57. class ConcreteStrategyA implements Strategy {
  58.     public doAlgorithm(data: string[]): string[] {
  59.         return data.sort();
  60.     }
  61. }
  63. class ConcreteStrategyB implements Strategy {
  64.     public doAlgorithm(data: string[]): string[] {
  65.         return data.reverse();
  66.     }
  67. }
  69. /**
  70.  * The client code picks a concrete strategy and passes it to the context. The
  71.  * client should be aware of the differences between strategies in order to make
  72.  * the right choice.
  73.  */
  74. const context = new Context(new ConcreteStrategyA());
  75. console.log('Client: Strategy is set to normal sorting.');
  76. context.doSomeBusinessLogic();
  78. console.log('');
  80. console.log('Client: Strategy is set to reverse sorting.');
  81. context.setStrategy(new ConcreteStrategyB());
  82. context.doSomeBusinessLogic();

参考资料

  1. 策略模式
  2. 60 | 策略模式（上）：如何避免冗长的if-else/switch分支判断代码？
  3. 策略模式 —- 修言