《消失的设计模式》系列之策略模式

设计模式是面向对象的有用工具，但是编程语言的发展和多种编程范式混合编程的可能，使很多的模式被语言特性取代，或者被其他编程范式解决。

要解决的问题

想象一下，对于某个任务，我们需要支持多种解决方案。而这多种支持就是变化点，为了封装变换点，我们可以采用策略模式。

定义

定义了一系列的算法，把它们分别封装起来，并且使它们可以相互替换。

此模式让算法的变化独立于使用算法的客户。

面向对象的方式

UML

如上图所示，

Strategy 接口定义了算法的行为

一系列的算法 ConcreteStrategyA 和 ConcreteStrategyB 分别实现了该接口

策略被包含在一个 Context 中，拥有私有的 strategy 实例，从而执行具体的算法行为

通常 Context 中还会包含一个 setStrategy 方法，从而动态改变策略

代码

首先我们定义一个接口 IStrategy


interface IStrategy {
  calculate(a: number, b: number): number
}

它要求实现一个名为 calculate 的方法，该方法接受两个 number 类型的参数，最终返回一个 number 类型的值。


class AddStrategy implements IStrategy {
  calculate(a: number, b: number): number {
    return a + b
  }
}

class SubtractStrategy implements IStrategy {
  calculate(a: number, b: number): number {
    return a - b
  }
}

这里我们定义了两个具体的策略类 AddStrategy 和 SubtractStrategy，它们都实现了 IStrategy 接口。

最终我们来定义 Context 类：


class Context {
  private strategy: IStrategy

  constructor(strategy: IStrategy) {
    this.strategy = strategy
  }

  public setStrategy(strategy: IStrategy) {
    this.strategy = strategy
  }

  public calculate(a: number, b: number) {
    return this.strategy.calculate(a, b)
  }
}

类中包含一个私有的成员属性 strategy，可以通过构造函数赋值，也可以通过 setStrategy 来动态改变。最后 calculate 方法将会代理到具体的策略类上，并执行具体的算法。


const context = new Context(new AddStrategy())
console.log(context.calculate(1, 2)) 
context.setStrategy(new SubtractStrategy())
console.log(context.calculate(1, 2)) 

context.setStrategy(new SubtractStrategy())
console.log(context.calculate(1, 2))

完整代码

带上函数式的思考帽

我们再回过头来思考策略的定义方式：


interface IStrategy {
  calculate(a: number, b: number): number
}

这里的接口表达的意思是，期望一个类，拥有 calculate 方法，同时方法的签名是 (number, number) -> number。

其实真正想要的，只是里面的这个方法而已，我们大可不必将其放在类里面。可以把接口修改成如下的样子：


interface IStrategy {
  (a: number, b: number): number
}

这里 IStrategy 表达的意思是，一个函数，类型为 (number, number) -> number。如有有些不好理解的话，我们可以将其改为 type:


type IStrategy = (a: number, b: number) => number

那么相应的策略可以修改为：


const AddStrategy: IStrategy = (a, b) => a + b
const SubtractStrategy: IStrategy = (a, b) => a - b

这时，Context 就变成了：


class Context {
  private strategy: IStrategy

  constructor(strategy: IStrategy) {
    this.strategy = strategy
  }

  public setStrategy(strategy: IStrategy) {
    this.strategy = strategy
  }

  public calculate(a: number, b: number) {
    return this.strategy(a, b)
  }
}

const context = new Context(AddStrategy)
console.log(context.calculate(1, 2)) 
context.setStrategy(SubtractStrategy)
console.log(context.calculate(1, 2)) 

context.setStrategy(SubtractStrategy)
console.log(context.calculate(1, 2))

只是传入一个函数而已！去掉了类的层层包裹，一个函数就可以清晰明了地解决问题。

由于场景的设定，这里我们就不去将 Context 函数式化了。完整代码

数组的排序算法与策略模式

其实日常编码中，遇到最多的策略模式是排序算法，例如：


;[1, 5, 3, 4, 2].sort((a, b) => a - b)

在 TypeScript 中，自定义排序策略非常容易，传入一个函数就可以了，我们再来看 Java 的表现：


class CustomComparator implements Comparator<X> {

  public int compare(X a, x b) {
    return ...
  }
}

CustomComparator comparator = new CustomComparator()
Arrays.sort(arr, new CustomComparator())

其中 comparator 是一个实现了 Comparator 接口的类的实例。为了满足类型，需要定义类，然后创建实例对象，非常冗余。

总结

策略模式，其目的是使不同算法族变得可控。其方法是将符合统一接口的不同行为的类的实例注入进入。但是如果能使用函数式的方式，其实传一个函数参数，就可以了。

参考

Head first design patterns

https://cuipengfei.me/blog/2015/05/27/trait-and-fp-makes-strategy-pattern-irrelevant/