多种方法优于切换的优势

我今天收到一位高级开发人员的代码审查，询问“顺便问一下，您反对通过switch语句分派功能吗？” 我已经在很多地方读到了关于如何通过切换到调用方法来泵送参数是不好的OOP，而不是可扩展的，等等。但是，我无法真正为他提供明确的答案。我想一劳永逸地解决这个问题。

这是我们的竞争代码建议（以php为例，但可以更普遍地应用）：

class Switch {
   public function go($arg) {
      switch ($arg) {
         case "one":
            echo "one\n";
         break;
         case "two":
            echo "two\n";
         break;
         case "three":
            echo "three\n";
         break;
         default:
            throw new Exception("Unknown call: $arg");
         break;
      }
   }
}

class Oop {
   public function go_one() {
      echo "one\n";
   }
   public function go_two() {
      echo "two\n";
   }
   public function go_three() {
      echo "three\n";
   }
   public function __call($_, $__) {
      throw new Exception("Unknown call $_ with arguments: " . print_r($__, true));
   }
}

他的部分论点是“与普通的__call（）魔术方法相比，它（切换方法）在处理默认案例方面有一种更干净的方法。”

我不同意清洁度，实际上更喜欢打电话，但我想听听别人怎么说。

我可以提出支持该Oop方案的论点：

• 就您必须编写的代码而言，它更简洁（更少，更易于阅读，更少考虑的关键字）
• 并非所有动作都委派给单个方法。此处的执行没有太大区别，但至少文本更加分隔。
• 同样，可以在类中的任何位置而不是特定位置添加另一种方法。
• 方法带有名称空间，这很好。
• 不适用于此处，而是考虑Switch::go()对成员而不是参数进行操作的情况。您必须先更改成员，然后再调用方法。因为Oop您可以随时独立地调用方法。

我可以提出支持该Switch方案的论点：

• 为了争辩，使用更干净的方法处理默认（未知）请求
• 似乎不那么神奇，这可能会使不熟悉的开发人员感到更自在

任何人都可以添加任何内容吗？我想给他一个很好的答案。

交换机不是OOP，因为通常多态性可以解决问题。

在您的情况下，OOP实现可能是这样的：

class Oop 
{
  protected $goer;

  public function __construct($goer)
  {
    $this->goer = $goer;
  }

  public function go()
  {
    return $this->goer->go();
  }
}

class Goer
{
  public function go()
  {
    //...
  }
}

class GoerA extends Goer
{
  public function go()
  {
    //...
  }
}

class GoerB extends Goer
{
  public function go()
  {
    //...
  }
}

class GoerC extends Goer
{
  public function go()
  {
    //...
  }
}


$oop = new Oop(new GoerB());
$oop->go();

对于此示例：

class Switch
{
    public function go($arg)
    {
        echo "$arg\n";
    }
}

好的，这里只是在开玩笑。对于此类琐碎的示例，不能强烈地提出使用switch语句的观点，因为OOP端取决于所涉及的语义，而不仅取决于分派机制。

switch语句通常表示缺少类或分类，但不一定。有时switch语句只是switch语句。

也许不是答案，但是对于非转换代码，看起来这将是更好的匹配：

class Oop {
  /**
   * User calls $oop->go('one') then this function will determine if the class has a 
   * method 'go_one' and call that. If it doesn't, then you get your error.
   * 
   * Subclasses of Oop can either overwrite the existing methods or add new ones.
   */
  public function go($arg){

    if(is_callable(array($this, 'go_'. $arg))){
      return call_user_func(array($this, 'go_'. $arg));
    }

    throw new Exception("Unknown call: $arg");
  }

  public function go_one() {
    echo "one\n";
  }
  public function go_two() {
    echo "two\n";
  }
  public function go_three() {
    echo "three\n";
  }
}

要评估的难题中很大一部分是当您需要创建NewSwitch或创建时会发生什么NewOop。您的程序员是否必须通过一种或另一种方法来解决问题？当您的规则更改时会发生什么，等等。

不仅仅是将执行代码放入函数中，还可以实现完整的命令模式，并将每个命令模式放在实现公共接口的自己的类中。这种方法允许您使用IOC / DI来连接类的不同“案例”，并允许您随时间轻松地从代码中添加和删除案例。它还为您提供了很多不违反SOLID编程原理的代码。

我认为这个例子很糟糕。如果有一个接受参数$ where的go（）函数，则在该函数中使用switch是完全有效的。具有单个go（）函数可以更轻松地修改所有go_where（）方案的行为。另外，您将保留类接口-如果使用各种方法，则将用每个新的目标修改类的接口。

实际上，switch不应替换为方法集，而应替换为类集-这是多态性。然后，目标将由每个子类处理，并且所有子类都有一个go（）方法。Martin Fowler描述了用多态替换条件是基本重构之一。但是您可能不需要多态性，而切换是必须的。