策略模式优化代码中的 Switch Case

以下代码在后期会增加非常多的 BufferType，使用新的方式实现它并且移除掉 addBuffer 中的 switch

enum BufferType {
  stun,
  silence,
  removeBuff,
}
 
class Hero {
  stun: boolean;
  silence: boolean;
 
  addBuffer(bufferType: BufferType)
    switch(bufferType) {
      case Buffer.stun:
        // do something
        break;
      case Buffer.silence:
        // do something
        break;
      case Buffer.removeBuff:
        // do something
        break;
      ...
    }
  }
}
 

使用策略模式

在游戏开发中，buffer 可能有成百上千种，前期 buffer 类型少的时候还好，等后期类型多了，每次新增新的 buffer 就要去修改 addBufer 方法，在其中添加新的 buffer 处理逻辑，这样每次都要去修改 addBuffer 方法，长久来说很不安全，而且后期type 增多时，addBuffer 方法会越来越长，可以使用 策略模式来优化这段代码

策略模式允许你定义一系列的算法（在这里是处理不同类型的 Buffer）把他们封装起来，并使他们可以相互替换，这样的封装改变了算法的使用方式，而不是算法本身，从而使得算法能够独立于使用它的客户端变化

/**
 * 游戏添加 Buffer 的类
 */
 
enum BufferType {
  stun,
  silence,
  removeBuff,
}
 
class Buff {
  bufferType: BufferType;
 
  constructor(bufferType: BufferType) {
    this.bufferType = bufferType;
  }
 
  getBufferType() {
    return this.bufferType;
  }
 
  trigger(hero: Hero) {}
 
  static newBuff(bufferType: BufferType) {
    switch (bufferType) {
      case BufferType.stun:
        return new Stun(bufferType);
      case BufferType.silence:
        return new Silence(bufferType);
      case BufferType.removeBuff:
        return new RemoveBuff(bufferType);
      default:
        return new Buff(bufferType);
    }
  }
}
 
class Stun extends Buff {
  trigger(hero: Hero) {
    hero.stun = true;
  }
}
 
class Silence extends Buff {
  trigger(hero: Hero) {
    hero.silence = true;
  }
}
 
class RemoveBuff extends Buff {
  trigger(hero: Hero) {
    hero.stun = false;
    hero.silence = false;
  }
}
 
class Hero {
  stun: boolean;
  silence: boolean;
 
  addBuffer(bufferType: BufferType) {
    const buff = Buff.newBuff(bufferType);
    buff.trigger(this);
  }
}
 

上面的代码中，创建了一个 Buff 的基类，并且带有一个 静态的构造方法，所有的 bufer 通过这个基类构造，并且每个 bufferType 的处理逻辑在各自的类中，这样写的好处是， Hero 中的 addBuffer 将保持稳定，轻易不会修改，后续涉及到新增 bufferType,只需要新增一个继承自 Buff 的 buffer 类，并且在 Buff 的 newBuff 静态函数中判断实现它就可以了。

如果不想在Buff 类中继续使用 switch，可以使用 Map的数据结构来修改

使用 Map

1. 定义 Buffer 处理策略的接口

interface BufferStrategy {
  handle(): void;
}

1. 为每种 BufferType 实现一个策略类

class StunStrategy implements BufferStrategy {
  handle() {
    // 实现stun的处理逻辑
  }
}
 
class SilenceStrategy implements BufferStrategy {
  handle() {
    // 实现silence的处理逻辑
  }
}
 
// 为其他 BufferTypes 实现更多策略...
 

1. 修改 Hero 类来使用策略

class Hero {
  private bufferStrategies: Map<BufferType, BufferStrategy>;
 
  constructor() {
    this.bufferStrategies = new Map([
      [BufferType.stun, new StunStrategy()],
      [BufferType.silence, new SilenceStrategy()],
      // 添加更多的映射...
    ]);
  }
 
  addBuffer(bufferType: BufferType) {
    const strategy = this.bufferStrategies.get(bufferType);
    if (strategy) {
      strategy.handle();
    } else {
      // 处理无效的 BufferType
    }
  }
}