函数式和面向对象编程有什么区别？

函数式编程 (Functional Programming) 和 面向对象编程 (Object Oriented Programming) 是两个主流的编程范式，他们有各自独特的闪光点，比如函数式编程的数据不可变、惰性求值，面向对象编程的继承、多态等。这些语言特性上的区别，可以参考之前的文章，这篇文章主要从实现相同功能的角度，来对比这两种编程范式，他们在实现上的逻辑是截然相反的。

初步实现

在函数式编程中，代码逻辑通常是按照要做什么。而在面向对象编程中，通常是把代码逻辑抽象成 class，然后给这些 class 一些操作。这么说起来很抽象，用下面这个例子来详细说明。

假设我们要用 函数式编程 和 面向对象编程 来分别实现下面这些功能：

	eval	toString	hasZero
Int
Add
Negate

表格左列 Int, Add, Negate 是三个变式 (Variant)，eval, toString, hasZero 是三种操作，这里要做的是填满这个表格，分别实现三个变式的三种操作。

函数式编程实现

这里用 ML 来做函数式编程的实现，即使没用过这门语言，应该也能读懂大概意思。

datatype exp =
    Int    of int
  | Negate of exp
  | Add    of exp * exp

exception BadResult of string

fun add_values (v1,v2) =
    case (v1,v2) of
    		(Int i, Int j) => Int (i+j)
      | _ => raise BadResult "non-values passed to add_values"

fun eval e =
    case e of
    		Int _       => e
      | Negate e1   => (case eval e1 of
                          Int i => Int (~i)
      | _ => raise BadResult "non-int in negation")
      | Add(e1,e2)  => add_values (eval e1, eval e2)

fun toString e =
    case e of
        Int i 			=> Int.toString i
      | Negate e1   => "-(" ^ (toString e1) ^ ")"
      | Add(e1,e2)  => "("  ^ (toString e1) ^ " + " ^ (toString e2) ^ ")"

fun hasZero e =
    case e of
      	Int i 			=> i=0
      | Negate e1   => hasZero e1
      | Add(e1,e2)  => (hasZero e1) orelse (hasZero e2)

在函数式编程中，先定义了一个数据类型 (datatype) 来表示 Int, Negate, Add，这样定义的目的是什么呢？举个表达式的例子：

• Int 代表一个 int 的数据，比如 Int(2)
• Negate 代表 Int 的负数，比如 Negate(Int(2)))
• Add 代表两个 Int 相加，比如 Add((Int(2), Int(3))

然后再分别实现三个操作 eval, toString, hasZero：

• eval 是给一个表达式求值，比如给 Negate 求值，eval(Negate(Int(2))) = Int(-2) ，给 Add 求值，eval(Add(Int(2), Int(3))) = Int(5)
• toString 是把这个表达式输出成字符串，比如 toString(Add(Int(2), Int(3))) = "2 + 3"。
• hasZero 是判断表达式有没有 0。

再看刚刚这句话函数式编程的代码逻辑通常是按照要做什么，这里的主体是三个操作，eval, toString 和 hasZero，所以三个分别是一个函数，在函数里去实现三种变式怎么操作。

可以说，函数式编程式纵向的填满了上面的表格。

面向对象编程

这里用 Ruby 来实现。

class Exp
end

class Value < Exp
end

class Int < Value
  attr_reader :i
  def initialize i
    @i = i
  end
  def eval # no argument because no environment
    self
  end
  def toString
    @i.to_s
  end
  def hasZero
    i==0
  end
end

class Negate < Exp
  attr_reader :e
  def initialize e
    @e = e
  end
  def eval
    Int.new(-e.eval.i) # error if e.eval has no i method
  end
  def toString
    "-(" + e.toString + ")"
  end
  def hasZero
    e.hasZero
  end
end

class Add < Exp
  attr_reader :e1, :e2
  def initialize(e1,e2)
    @e1 = e1
    @e2 = e2
  end
  def eval
    Int.new(e1.eval.i + e2.eval.i) # error if e1.eval or e2.eval has no i method
  end
  def toString
    "(" + e1.toString + " + " + e2.toString + ")"
  end
  def hasZero
    e1.hasZero || e2.hasZero
  end
end

< 在 Ruby 里是继承的意思，class Int < Value 表示 Int 继承了 Value，Int 是 Value 的 Subclass。

可以看到面向对象编程组织代码的方式和之前的完全不一样。这里把 Int, Negate, Add 抽象成了三个 class，然后分别给每个 class 加上 eval, toString, hasZero 三个方法。这也是刚刚那句话的说法 面向对象编程把代码逻辑抽象成 class，然后给这些 class 一些操作，这里的主体是 Int, Negate, Add 这三个 class。

可以说，面向对象编程是横向的填满了上的表格。

通过这个对比，可以知道 函数式编程 和 面向对象编程 是两种相反的思维模式和实现方式。这两种方式对代码的扩展性有什么影响呢？

扩展实现

	eval	toString	hasZero	absolute
Int
Negate
Add
Multi

在上面那个例子的基础上，我们再加一行一列，增加 Multi 这个变式，表示乘法，增加 absolute 这个操作，作用是求绝对值。这会怎么影响我们的代码呢？

函数式编程

在函数式编程中，要增加一个操作 absolute 很简单，只要添加一个新的函数，不用修改之前的代码。但是要增加 Multi 比较麻烦，要修改之前的所有函数。

面向对象编程

和函数式编程相反的，在这里增加一个 Multi 简单，只要添加一个新的 class，但是增加 absolute 这个操作就要在之前的每一个 class 做更改。

选择用 函数式编程 还是 面向对象编程 的一个考量因素是以后将会如何扩展代码，对之前代码的更改越少，出错的概率越小。

Binary Methods

前面的对比，操作都是在一个数据类型上进行的，这里进行最后一个对比，一个函数对多个数据类型进行操作时，函数式和面向对象分别怎么实现。

	Int	String	Rational
Int
String
Rational

这里要实现的是一个 add_values(x, y) 的操作，把两个数据相加，但是 x, y 可能是不同的类型的。

函数式编程

函数式编程的实现相对简单：

datatype exp =
    Int    of int
  | String of string
  | Rational of real

fun add_values (v1,v2) =
    case (v1,v2) of
				(Int i,  Int j)         => Int (i+j)
      | (Int i,  String s)      => String(Int.toString i ^ s)
      | (Int i,  Rational(j,k)) => Rational(i*k+j,k)
      | (String s,  Int i)      => String(s ^ Int.toString i) (* not commutative *)
      | (String s1, String s2)  => String(s1 ^ s2)
      | (String s,  Rational(i,j)) => String(s ^ Int.toString i ^ "/" ^ Int.toString j)
      | (Rational _, Int _)        => add_values(v2,v1)
      | (Rational(i,j), String s)  => String(Int.toString i ^ "/" ^ Int.toString j ^ s)
      | (Rational(a,b), Rational(c,d)) => Rational(a*d+b*c,b*d)
      | _ => raise BadResult "non-values passed to add_values"

这里的操作是 add_values，所以只要把所有可能的数据类型（总共9种）都列出来，就可以了。

面向对象编程：二次分派

按照上面面向对象编程的例子，我们可以这么做：

class Int < Value
	...
  def add_values v
    if v.is_a? Int
      i + v.i
    elsif v.is_a? MyString
      i.to_s + v.i
    else
      ...
    end
  end
end

class MyString < Value
  ...
end

在 add_values 这个方法里面去做判断，看传入参数的类型，去做相应的操作。这种做法不是那么的 面向对象，可以有另外一种写法：

class Int < Value
	...
  # double-dispatch for adding values
  def add_values v # first dispatch
    v.addInt self
  end
  def addInt v # second dispatch: other is Int
    Int.new(v.i + i)
  end
  def addString v # second dispatch: other is MyString (notice order flipped)
    MyString.new(v.s + i.to_s)
  end
  def addRational v # second dispatch: other is MyRational
    MyRational.new(v.i+v.j*i,v.j)
  end
end

class MyString < Value
  ...
  # double-dispatch for adding values
  def add_values v # first dispatch
    v.addString self
  end
  def addInt v # second dispatch: other is Int (notice order is flipped)
    MyString.new(v.i.to_s + s)
  end
  def addString v # second dispatch: other is MyString (notice order flipped)
    MyString.new(v.s + s)
  end
  def addRational v # second dispatch: other is MyRational (notice order flipped)
    MyString.new(v.i.to_s + "/" + v.j.to_s + s)
  end
end
...

这里涉及到了一个概念 二次分派 (Double Dispatch)，在一次方法的调用过程中，做了两次 动态分派 (Dynamic Dispatch) 。用例子来说明

i = Int.new(1)
s = MyString.new("string")
i.add_values(s)

i.add_values(s)在调用这个方法时，实现了一次 dispatch，到 add_values 这个方法里后，做的其实是 s.addInt i，也就是去调用了 MyString 里的 addInt 这个方法，这是第二次 dispatch，所以叫做 double dispatch。

总结

函数式编程 和 面向对象编程 对比下来，我们并不能说哪一种模式更好。但是可以看出它们在思维上是截然不同的。函数式编程中侧重要做什么，面向对象编程侧重对象的抽象化，在有些编程语言里，比如 Java，是都可以实现的，但是要用哪种还要根据需求具体考虑。如果要了解更多 函数式编程 和 面向对象编程 的基础概念的话，可以看看之前的这三篇文章。

推荐阅读：
编程语言的一些基础概念（一）：静态函数式编程
编程语言的一些基础概念（二）：动态函数式编程
编程语言的一些基础概念（三）：面向对象