在本文中，将展示编写Ruby函数式代码的一种绝佳的方式。这种方式将使我们摆脱摆脱奇怪通顺的代码，编写非比寻常的纯函数的代码。。

在Ruby中所有函数都是方法，所有本文中的"函数" 和 "方法"是相同的。

我将从定义什么是纯函数开始，讲解它的好处，最后会通过一个实例来加以说明。

纯函数

纯函数是函数式编程的核心概念，判断一个函数是否是纯函数，需要通过一下两点：

• 无副作用
• 引用透明

副作用是通过函数调用触发的，任何可观察的变化。

引用透明是函数式编程中，描述一个函数的返回值，完全取决于它的参数，也就是给定一个同样的参数，引用透明的函数，不管被调用多少次，它总会返回相同的结果。例如：add(2, 5) => 7 就是一个引用透明的函数，而使用rand 的函数就肯定不是，因为它的返回值会变化。

纯度的好处

纯函数，可以提供两个保障来让你的工作变得容易。

第一个保障就是，当你调用一个纯函数时，它不会破坏任何东西。如果一个函数从副作用中解放出来，那么它就不会破坏软件的其他部分。这意味着你不需要在问自己 "如果调用这个函数，会有什么糟糕的结果。"，而只需要关心函数的返回值。

第二个保障是，函数的返回值是完全可预测的。如果你提供正确的参数，它就会永远返回正确的结果，结果百分百在你的掌控之中，这将使得代码易于编写和调试。

另外，这两个保障同时表明纯函数的返回值是可缓存的。如果你有一个相对比较关心性能的纯函数，它可以很容易缓存，纯函数的参数就可以充当 缓存的key，value就是 函数的返回值，这种返回值模式称为：备忘录模式。

示例: JSON To XML 转换器

为了展示这种模式，我们着手来编写一个转换JSON到XML的程序。整个项目已经发布到Github上：https://github.com/tomdalling/pure-function-as-an-object

程序的输入是这样的：

{ "city" : "AGAWAM", "loc" : [ -72.622739, 42.070206 ], "pop" : 15338, "state" : "MA", "_id" : "01001" }
{ "city" : "CUSHMAN", "loc" : [ -72.51564999999999, 42.377017 ], "pop" : 36963, "state" : "MA", "_id" : "01002" }
{ "city" : "BARRE", "loc" : [ -72.10835400000001, 42.409698 ], "pop" : 4546, "state" : "MA", "_id" : "01005" }
{ "city" : "BELCHERTOWN", "loc" : [ -72.41095300000001, 42.275103 ], "pop" : 10579, "state" : "MA", "_id" : "01007" }
{ "city" : "BLANDFORD", "loc" : [ -72.936114, 42.182949 ], "pop" : 1240, "state" : "MA", "_id" : "01008" }

输出应该像这样的：

<?xml version="1.0"?>
<cities count="5">
  <city id="01001" name="AGAWAM" state="MA" location="-72.622739,42.070206" population="15338"/>
  <city id="01002" name="CUSHMAN" state="MA" location="-72.51565,42.377017" population="36963"/>
  <city id="01005" name="BARRE" state="MA" location="-72.108354,42.409698" population="4546"/>
  <city id="01007" name="BELCHERTOWN" state="MA" location="-72.410953,42.275103" population="10579"/>
  <city id="01008" name="BLANDFORD" state="MA" location="-72.936114,42.182949" population="1240"/>
</cities>

我们只需要使用Ruby 2.3和Ox gem 来编写程序，现在开始吧。

API 设计

在收集需求后的下一步就是去想：这个程序有多少可以使用纯函数去实现？

结果就是，几乎所有的部分都可以使用纯函数实现。I/O部分是不纯的，但是JSON到XML的转换部分是纯的。相同的JSON总会转换成相同的XML。

转换器的API可以这样使用：

input = File.read('input.json')
output = JSON2XML.convert(input)
File.write('output.xml', output)

示例代码可以很容易测试，只需要一些模拟输入，然后断言output是否正确。

因为File.read和File.write不是纯的，我必须故意将它，与转换部分的代码分开，这样就允许转换部分可以是纯函数。— 仅仅是输入字符串和返回字符串。

假设输入的数据不会太大，API 看上还是非常不错，如果输入的数据非常大，我们就不能将所有数据都一次性加载到内存中了。那么我们就需要使用stream API，但是因为程序仅仅是作为展示，所有就可以假设数据不超过几MB大小。

动机

API 由一个方法组成，这个方法是纯函数，代码如下：

require 'json'
require 'ox'

module JSON2XML
  def self.convert(input_json)
    # TODO: implementation goes here
  end
end

我们可以很容易的，通过在JSON2XML module中，编写一堆纯函数，来实现所有的功能，而不需要定义任何新的类。这可行，但是我个人并不认为，这是Ruby设计使用的方式。也不是大多数人使用Ruby的惯用方式。这与语言设计相违背。

使用Ruby的方式，我们需要定义一个类，尽管类不是必须的。API就是一个纯函数，所以没有人会将这个类实例化。

模式背后的动机：我们想要将API定义成简单的纯函数，但我们也想要在一个私有类中实现这些。

模式

废话少说，下面上代码：

require 'json'
require 'ox'

class JSON2XML
  def self.convert(input_json)
    new(input_json).send(:xml)
  end

  private
    def initialize(input_json)
      @input_json = input_json
    end

    def xml
      # TODO: implementation goes here
    end
end

现在JSON2XML变成了类。convert下面的所有代码都是私有的，这表示了convert方法是唯一的应该被调用的方法，剩下其他的方法都是实现细节。

在convert 方法中，它在首先初始化了自身，并且将参数传入构造方法，然后在通过send调用私有的xml方法。

上面就是模式实现的概览。

实现

现在我们来，继续完成JSON to XML的转换程序，为展示使用这种模式的优点。

xml方法目前是空的。convert方法期望它返回XML字符串。如何生成XML?，一种方法就是使用XML文档对象，然后将其序列化：

def xml
  Ox.dump(document, with_xml: true)
end

但是我们并没有定义document。

如何创建document对象？自打我们使用 Ox gem，我们就需要实例化一个Ox::Document对象，并且在其中设置一个根节点，这样所有内容就都会在Ox::Document对象中。

def document
  Ox::Document.new(version: '1.0').tap do |doc|
    doc << root_node
  end
end

然后我们还需要定义缺失的root_node方法。

在Ox Gem中，我们需要实例化一个Ox::Element对象。我们需要将所有输出数据填充到根节点上，那么在根节点中，我们就遍历放入所有city_nodes的数据。同时根节点还需要 "count"属性。

再定义city_nodes方法，每个city节点同样也是一个Ox::Element对象。那么就从input_json中分行处理city节点。

def city_nodes
  input_json.each_line.map { |line| parse_city_node(line) }
end

input_json 实际上就是我们初始化类的时候传入的json参数，我们通过定义一个访问器来使用它：

attr_reader :input_json

parse_city_node 方法

def parse_city_node(line)
  Ox::Element.new('city').tap do |city|
    attrs = JSON.parse(line)

    city[:id] = attrs.fetch('_id')
    city[:name] = attrs.fetch('city')
    city[:state] = attrs.fetch('state')
    city[:location] = attrs.fetch('loc').join(',')
    city[:population] = attrs.fetch('pop').to_s
  end
end

完整的类如下：

class JSON2XML
  def self.convert(input_json)
    new(input_json).send(:xml)
  end

  private
    attr_reader :input_json

    def initialize(input_json)
      @input_json = input_json
    end

    def xml
      Ox.dump(document, with_xml: true)
    end

    def document
      Ox::Document.new(version: '1.0').tap do |doc|
        doc << root_node
      end
    end

    def root_node
      Ox::Element.new('cities').tap do |root|
        root[:count] = city_nodes.size
        city_nodes.each { |city| root << city }
      end
    end

    def city_nodes
      input_json.each_line.map { |line| parse_city_node(line) }
    end

    def parse_city_node(line)
      Ox::Element.new('city').tap do |city|
        attrs = JSON.parse(line)

        city[:id] = attrs.fetch('_id')
        city[:name] = attrs.fetch('city')
        city[:state] = attrs.fetch('state')
        city[:location] = attrs.fetch('loc').join(',')
        city[:population] = attrs.fetch('pop').to_s
      end
    end
end

我们刚才展示的是，如何将整个实现，由上而下逐步分解。刚开始你只想要得到结果 - 在这个例子中就是 XML字符串，继续先后，你编写一些你希望存在的方法，并在之后实现它。这是一种将复杂算法逐步分解更小的部分的，绝佳方式。

我们能够实现这个例子得益于Ruby的语法，在Ruby的语法中，它模糊了方法调用和本地变量调用的区别，这就使得我们可以先编写标识符来表示需要的值，再然后编写具体的实现方法。这样就利用了语言的优势。

注意：这里编写的方法都是没有副作用的。类中的每一个方法自身都是纯函数。@input_json 实例变量一直没有被改变，它本质上是一个常量。因此我们期望每一个方法无论如何都会返回相同的值，比如你调用xml方法三次，那么你将会得到三个相同的字符串。

优化

机智的读者可能会发现在rode_node方法存在性能问题。

def root_node
  Ox::Element.new('cities').tap do |root|
    root[:count] = city_nodes.size
    city_nodes.each { |city| root << city }
  end
end

这里我在根节点上，放置了一个 "count"属性，就是为了展示这种模式下，常见的性能问题。

问题就是，code_nodes 被调用了两次，这意味着我们需要解析整个数据集两次，这是非常不必要的性能浪费。

因为所有方法都是纯函数，所有我们有一个非常简单的解决办法： 备忘录模式。因为city_nodes的引用透明特点和无参数传递。所有我们就知道city_nodes每次返回的都是相同的值。

解决方法：

def city_nodes
  @city_nodes ||= input_json.each_line.map { |line| parse_city_node(line) }
end

修改后的city_nodes除了使用 ||=这个操作符之外和原来没有任何差别。

现在就算调用city_nodes再多次，也不用担心性能问题了。这个简洁的方法使用了实例变量，并且利用了Ruby语言的惰性取值。

何时使用PFAAO

这种模式非常好实现复杂的纯函数。我已经使用这个模式，愉快的开发了DOCX to HTML的转换程序。

如果问题的实现是简单的，那么就不值得编写一个类去解决它，仅仅使用一个稍微大一点的函数就可以了。如果你编写的是纯函数，并且它已经增长到难以控制的地步，这时就需要好好考虑是否应该使用这种模式了。

当问题的实现大部分是纯函数的，但不完全是，你依然可以使用这种模式，实现可能会变得复杂，但是仍有小的简单的API可以使用纯函数。Ruby毕竟不是Haskell，我们使用带有副作用的方法，也是合情理的。

如果你的实现大部分都需要可变状态的话，使用PFAAO就不合适了。

可选部分

• 禁止类实例化

  不幸运的是，将构造方法变为私有，并不能阻止类的实例化。需要指明除了类方法外，其他都不应该被调用，更不应该初始化，所以我们应该通过抛出异常的方式，告诉调用者这些信息。在类定义中填写下面的代码，就会在初始化该类的时候抛出异常。

  private_class_method :new
  

• Proc

  Ruby中，像Proc这样类似函数的类，只能通过call方法去调用，上面的转换程序，也可以将convert方法改为call方法，让它的行为像Proc，但同时也需要将类的名字改为XML2JSONConverter。

• 使用Proc

  如果你经常在block中使用PFAAO，如下：

  documents.map{ |d| XML2JSON.convert(d) }
  

  这时使用block语法传参会是更好的选择。

  documents.map(&XML2JSON)
  

  我们可以通过实现to_proc方法，来实现它。

  def self.to_proc
    method(:convert).to_proc
  end
  

  ​

结论

使用函数式风格编写Ruby代码，是可行的，甚至是更好的方式。没有monads和分类理论的要求，复杂的纯函数完全可以使用Ruby编写。

英文原文地址