스위치를 통한 여러 방법의 장점

오늘 선임 개발자로부터 코드 검토를 받았습니다. 나는 여러 곳에서 스위치를 호출하는 메소드를 통해 인수를 펌핑하는 것이 나쁜 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";
    }
}

좋아, 부분적으로 농담이야. 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 () 시나리오의 동작을보다 쉽게 ​​수정할 수 있습니다. 또한 클래스 인터페이스를 유지합니다. 다양한 방법을 사용하는 경우 새 대상마다 클래스의 인터페이스를 수정합니다.

실제로 스위치는 메소드 세트로 바꾸지 말고 클래스 세트로 바꾸어야합니다. 이것은 다형성입니다. 그런 다음 대상은 각 서브 클래스에 의해 처리되며 모든 대상에 대해 단일 go () 메소드가 있습니다. 조건부를 다형성으로 교체하는 것은 Martin Fowler가 설명한 기본 리팩토링 중 하나입니다. 그러나 다형성이 필요하지 않을 수도 있으며 스위치가 나아갈 길입니다.