下面是最简单的一个 if 语句：

def f(input)
  if input == true
    "Hello!"
  else
    "Bye!"
  end
end

如果我们抛去 if 的外衣，尝试用自然语言来描述这段代码的话，它可以被翻译为：

• 在输入为 true 时，输出 "Hello!"
• 在输入不为 true 时，输出 "Bye!"

也就是说，这段代码实际上将一个输入集合映射到了一个输出集合上： f: {0, 1, ..., true, false, ...} -> {"Hello!", "Bye!"}

如果两个分支的行为变得更加复杂，每个分支并不仅仅是简单的返回数据，我们还能采用集合来理解他们吗？

def f(input)
  if input == true
    # branch T
  else
    # branch F
  end
end

在这种情况下，我们依然可以构造一个集合，集合中每个元素对应了每一个分支下的复杂行为。 f: {0, 1, ..., true, false, ...} -> {branch T, branch F}

这样一来，所有 if 语句都能通过这种方式变换为从一个「集合」到另一个「集合」的映射。因此，我们只需要通过其他方式来实现「集合」的映射，便能「不用 if 语句」实现分支语句的效果。

一提到「集合」的映射，我们很容易就能联想到「数组」这一常用的数据结构。通过定义一个「数组」，我们就定义了一组输入集合为 [0..n] 的映射。

MAP = [
        "Hello!",
        "Bye!",
      ]

def f(input)
  MAP[input]
end

但是这样的映射只能在输入集合为自然数集时使用，如果输入集合包含了自然数之外的类型，该如何解决呢？

这时，我们可以将数组转换为哈希表(Hash)，接受所有可能的输入类型：

MAP = {
  0 => "Hello!",
  1 => "Bye!",

  true => "Hello!",
  false => "Bye!",
}

def f(input)
  MAP[input]
end

使用哈希表之后，在输入集合、输出集合中都可以使用任意类型的数据，但要如何表示复杂的输出行为呢？这就需要用到 Ruby 等高级语言中的函数式特性：函数即数据。

MAP = {
  0 => Proc.new { puts "Hello!" },
  1 => Proc.new { puts "Bye!" },
  true => Proc.new { Net::HTTP.get('example.com', '/index.html') },
}

def f(input)
  MAP[input].()
end

这样一来，原本需要 if 语句表示的分支逻辑，就被抽象成了一组组映射数据。相比于简单粗暴的 if 语句，使用数据映射来实现分支让我们将所有输入/输出的可能性都一览无余地展现出来。这能帮我们梳理所有可能的输入条件，减少错漏。在需要增加分支时，也只需要在原有的数据结构里修改或者增加条目，减少了错综复杂的 if 语句嵌套。

当然，将分支表示为映射表也有其缺点。

当更多类似的映射表被抽象出来时，管理每个映射表的成本也会增加。为了降低代码维护的成本、理解的成本，我们可以将类似的映射分组，抽象成对象，给对象分类，给映射取名：

• 映射数据太多，不易维护

  SALUT_MAP = {
    0 => "Hello",
    1 => "Bye",
  }
  
  RECEIVER_MAP = {
    0 => "World",
    1 => "John",
  }
  
  def f(input)
    "#{SALUT_MAP[input]}, #{RECEIVER_MAP[input]}!"
  end
  

• 将映射分类，抽象为对象

  class Class0
    def salut
      "Hello"
    end
  
    def receiver
      "World"
    end
  
    def greeting
      "#{salut}, #{receiver}!"
    end
  end
  
  class Class1
    def salut
      "Bye"
    end
  
    def receiver
      "John"
    end
  
    def greeting
      "#{salut}, #{receiver}!"
    end
  end
  
  def f(input)
    Object.const_get("Class#{input}").new.greeting
  end
  

将分支抽象为对象/类之后，每个分支被进一步地分隔开来：原本每个分支散落在 if 语句中相邻的分支中；在映射数据中，这些分支变成了不同的数值对；在对象/类中，这些分支被切实地分到了不同的文件中。每次分隔，都让分支之间的互相影响降低。最终，每个分支都能够被独立修改，新的分支能够被独立添加，而不会影响到另外的分支。程序的可读性、可维护性也就提高了。

另外，当输入集合包含的可能性增加时，映射表的大小也会随之增加，如果输入集合是个无限的集合（比如自然数集），似乎就无法再用映射表来处理分支了。这时，对象/类又一次展示出了它的优势，它能够通过函数计算，将输入转换为对应的输出，进而表示无限集合之间的映射关系：

class Class0
  def initialize(input)
    @input = input
  end

  def salut
    "Hello"
  end

  def receiver
    "#{@input * 2}"
  end

  def greeting
    "#{salut}, #{receiver}!"
  end
end

经过上面的讨论，我们知道分支只不过是一个输入集合到一个输出集合的映射； if 语句将映射作为逻辑实现，不够直观；如果直接将这种映射关系作为数据表示，则能够大大增加代码的可读性和可维护性。

使用基本的数据类型（数组/哈希表），我们能简单明了地表示输入和输出之间的映射关系。如果情况变得复杂，我们可以使用对象/类来对映射关系进行抽象。最终，每个映射分支都被分隔开来，每个分支都能够被独立修改，不会互相影响。

以上就是如何简化一个 if 语句的方法。那么这种方法能不能推广到更高的层面，帮助我们更好地维护一个规模庞大的程序呢？