条件语句去重复的正确方法

Question

我面临的问题是，在每个函数(作为端点的服务)中，我需要检查查询参数(mode)的值。我需要检查许多可调用的设备，例如。

def create(self, arg, mode: Optional[Mode]):
    if mode:
        if mode == Mode.READ:
            do_something()
        elif mode == Mode.READ_RAW:
            do_something_else()
        else:
            raise Error("...")
    else:
        ...
    return something

我解决这个问题的方法是创建独立的类，如：

class ReadFacade:
    def __init__(self, read, read_raw):
        self._read_raw = read_raw
        self._read = read

    def read(self, mode: Mode, *args, **kwargs):
        if mode == Mode.READ:
            response = self._read(*args, **kwargs)
        elif mode == Mode.READ_RAW:
            response = self._read_raw(*args, **kwargs)
        else:
            raise Error("...")
        return response

它的意图是遮蔽所有这些条件，而不是像上面的create 1那样在每个函数中重复它。然后我可以在许多服务中使用它，如下所示：

class SomeService:
    def __init__(self,...):
        ...
        self._mode_handler = ReadFacade(
            read=self._service.read,
            read_raw=self._service.read_raw
        )
    
    def read(self, mode: Mode, *args, **kwargs):
        if mode:
            self._mode_handler.read(mode=mode, *args, **kwargs)
        else:    
            ...

我做得对吗?我能改进什么？它是否可以被命名为“正面”，或者它是另一种设计模式？

Answer 1

我认为您建议的重构不会改变任何事情:您的ReadFacade中仍然有很多条件，您只将mode == ...条件与if mode条件分开。但是，这真的使代码更容易理解吗？我怀疑这种额外的间接影响实际上会使代码更加复杂。

如果您关注的是嵌套If / can，请注意，在特定情况下可以很容易地解决这个问题。

而不是：

def create(self, arg, mode: Optional[Mode]):
    if mode:
        if mode == Mode.READ:
            do_something()
        elif mode == Mode.READ_RAW:
            do_something_else()
        else:
            raise Error("...")
    else:
        ...
    return something

我们可能会：

def create(self, arg, mode: Optional[Mode]):
    if not mode:
        ...
        return something

    if mode == Mode.READ:
        return do_something()

    if mode == Mode.READ_RAW:
        return do_something_else()

    raise Error("...")

要快速解决您的设计模式问题：

它是否可以被命名为“正面”，或者它是另一种设计模式？

这不是外观设计模式的一个例子。“设计模式”(Design)书中定义的外观概念是为一个子系统提供一个统一的接口，而不是要求客户端与多个不同的对象进行通信，现在他们只需要与在某些子系统上隐藏/封装/抽象的外观进行通信。您的系统实际上并不具有这些不同的对象。

如果您真的想从其他代码中筛选出模式条件，那么只需使用一个函数/方法：

class SomeService:
    
    def read(self, mode: Optional[Mode], *args, **kwargs):
        if mode:
            self._read_with_mode(mode, *args, **kwargs)
        else:    
            ...

    def _read_with_mode(self, mode: Mode, *args, **kwargs):
        if mode == Mode.READ:
            return self._service.read(*args, **kwargs)
        if mode == Mode.READ_RAW:
            return self._service.read_raw(*args, **kwargs)
        raise Error("...")

如果您想要一种更面向对象的方法，那么模式本身可能会提供作为一种策略模式的行为。例如：

class Mode:
  @abstract
  def read(self, service): ...

class ReadMode(Mode):
  def read(self, service):
    return service.read()

class ReadRawMode(Mode):
  def read(self, service):
    return service.read_raw()

class SomeService:
  def read(self, mode: Optional[Mode]):
    if mode:
      return mode.read(self._service)
    else:
      ...

还比较了用多态重构替换条件。