适配器模式可以用于对不同的接口进行包装以及提供统一的接口，或者是让某一个对象看起来像是另一个类型的对象。在静态类型的编程语言里，我们经常使用它去满足类型系统的特点，但是在类似Ruby这样的弱类型编程语言里，我们并不需要这么做。尽管如此，它对于我们来说还是有很多意义的。

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。——Gang of Four

假如你现在要管理游戏的服务器，而这个游戏有三个服务器，以服已经开放一段时间，二服和三服刚刚开放，现在你需要设计一个接口，要求传入不同的参数就能够获取到对应服的人数，如果传入的参数不合法，则返回-1。

首先定义一个父类，功能是统计在线人数。
Ruby Code:
class PlayerCount

    def server_name
        raise "You should override this method in subclass."
    end

    def player_count
        raise "You should override this method in subclass."
    end

end

接着定义三个子类，非别对应一服、二服、三服，代码如下。
Ruby Code:
class ServerOne < PlayerCount

    def server_name
        "一服"
    end

    def player_count
        Utility.online_player_count(1)
    end

end

class ServerTwo < PlayerCount

    def server_name
        "二服"
    end

    def player_count
        Utility.online_player_count(2)
    end

end

class ServerThree < PlayerCount

    def server_name
        "三服"
    end

    def player_count
        Utility.online_player_count(3)
    end

end

接着，定义一个XMLBuilder类，用来将不同服的数据封装成XML格式输出。
Ruby Code:
class XMLBuilder

  def self.build_xml player
        builder = ""
        builder << "<root>"
        builder << "<server>" << player.server_name << "</server>"
        builder << "<player_count>" << player.player_count.to_s << "</player_count>"
        builder << "</root>"
  end

end

通过如下方式来查询各个服的玩家的数量。
Ruby Code:
XMLBuilder.build_xml(ServerOne.new)
XMLBuilder.build_xml(ServerTwo.new)
XMLBuilder.build_xml(ServerThree.new)
这看起来很好，但是因为一服已经运行了一段时间，已经有了查询玩家在线数量的方法了，使用的是ServerFirst这个类。当时写Utility.online_player_count()这个方法主要是为了针对新开的二服和三服，就没把一服的查询功能再重复做一遍。这种情况下可以使用适配器模式，这个模式就是为了解决接口之间不兼容的问题而出现的。其实适配器模式的使用非常简单，核心思想就是只要能让两个互不兼容的接口能正常对接就行了。上面的代码中，XMLBuilder中使用PlayerCount来拼装XML，而ServerFirst并没有继承PlayerCount，这个时候就需要一个适配器类来为XMLBuilder和ServerFirst之间搭起一座桥梁，毫无疑问，ServerOne就将充当适配器类的角色。修改ServerOne的代码，如下所示：
Ruby Code:
class ServerOne < PlayerCount

    def initialize
        @serverFirst = ServerFirst.new
    end

    def server_name
        "一服"
    end

    def player_count
        @serverFirst.online_player_count
    end

end

需要值得注意的一点是，适配器模式不并是那种会让架构变得更合理的模式，更多的时候它只是充当救火队员的角色，帮助解决由于前期架构设计不合理导致的接口不匹配的问题。更好的做法是在设计的时候就尽量把以后可能出现的情况多考虑一些。

参考资料：

• https://martin91.github.io/blog/2014/03/03/jie-du-rails-gua-pei-qi-mo-shi/
• http://blog.csdn.net/guolin_blog/article/details/9400153

观察者模式（有时又被称为发布/订阅模式）是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。在Ruby标准库中，观察者模式得到了很好的支持，开箱即用，但是为了更好的说明解释观察者模式，我们首先看一个不利用Ruby的Observer机制的例子。

Observable

首先为被观察对象创建一个Observable模块，该模块的职能是在其状态发生改变时通知一个或多个观察者。
Ruby Code:
module Observable

  attr_accessor :state

  def attachObserver(o)
    @observers ||= []
    @observers << o if !@observers.include?(o)
  end

  def removeObserver(o)
    @observers.delete(o)
  end

  def state=(s)
    @state = s
    @observers.each do |o|
      o.update(self) # more on update() later!
    end
  end

end

方法attachObserver和removeObserver用来管理观察者，我们不想拥有相同的观察者，所以只添加那些没有观察我们定义的主体的观察者对象。
Ruby Code:
def state=(s)
@state = s
@observers.each do |o|
o.update(self) # more on update() later!
end
end
当被观察对象的状态发生了改变，就需要通知其观察了该对象的观察者。首先，我们覆写了有方法attr_accssor默认创建的修改器，在这个例子中是state=。在给state赋一个新的值后，调用所有观察者的update方法。

Observer

下面是Observer模块的实现：
Ruby Code:
module Observer

  def update(o)
    raise 'Implement this!'
  end

end

在该模块中，将update的具体功能留给包含它的类来实现，通过这种方式，Observer模块的行为就像是一个需要被其包含者实现的抽象类。

蚁群

作为一个简单的例子，首先定义我们的主体，也就是被观察者–蚂蚁女王。
Ruby Code:
class QueenAnt
include Observable
end
接下来定义一个观察者：
Ruby Code:
class WorkerAnt
include Observer

  def update(o)
    p "I am working hard. Queen has changed state to #{o.state}!"
  end
end

类WorkerAnt定义了在蚂蚁女王的状态发生改变时的特殊行为。
Ruby Code:
queen = QueenAnt.new

worker1 = WorkerAnt.new
worker2 = WorkerAnt.new
worker3 = WorkerAnt.new

queen.attachObserver(worker1)
queen.attachObserver(worker2)

queen.state = 'sleeping'
# I am working hard. Queen has changed state to sleeping!"
# I am working hard. Queen has changed state to sleeping!"

当蚂蚁女王的状态发生了改变，实例worker1、worker2会收到通知，并针对性的做出响应，实例worker3并没有并加入观察者列中，所以它不会受到通知。

Obserever机制

通过Ruby的Observer机制来实现观察者模式是很便捷的，只需要将observer模块混入被观察者对象就可以。
Ruby Code:

# require the observer lib file
require “observer”
class Notifier
end

class EmailNotifier < Notifier
  def update(bank_account)
    if bank_account.balance <= 10
      puts “Sending email to: ‘#{bank_account.owner}’ informing \n
            him with his account balance: #{bank_account.balance}$.”
      # send the email mechanism
    end
  end
end

class SMSNotifier < Notifier
  def update(bank_account)
    if bank_account.balance <= 0.5
      puts “Sending SMS to: ‘#{bank_account.owner}’ informing \n
           him with his account balance: #{bank_account.balance}$.”
      # send sms mechanism
    end
  end
end

class BankAccount
  # include the observable module
  include Observable
  attr_reader :owner,:balance
  def initialize(owner,amount)
    @owner,@balance = owner,amount
    # adding list of observes to the account
    add_observer EmailNotifier.new
    add_observer SMSNotifier.new
  end

  # withdraw operation
  def withdraw(amount)
    # do whatever you need
    @balance -=amount if (@balance - amount) > 0
    # now here comes our logic
    # issue that the account has changed
    changed
    # notify the observers
    notify_observers self
  end
end
account = BankAccount.new “Jim Oslen”, 100
account.withdraw 99.5
#=>Sending email to: ‘Jim Oslen’ informing him with
#his account balance: 0.5$.
#=>Sending SMS to: ‘Jim Oslen’ informing him with his
#account balance: 0.5$.

利用Ruby的Observer机制我们要做下面的工作：

• 引入observer库并将其包含在被观察者类中。
• 改变对象的状态并通知观察者。
• 让所有需要的观察者和被观察者关联。
• 每个观察者必须实现update方法。

总结

观察者模式和策略模式之间有一些相似之处,二者都是用一个对象（观察者模式的被观察者对象和策略模式的上下文对象）调用另一个对象（观察者模式的观察者和策略模式的策略）。二者的区别在于目的和适用情形的不同，观察者模式通过观察主题的不同状态来做出响应，策略模式则依赖于具体的策略来实现。

参考资料：

• http://blog.khd.me/ruby/observer-and-singleton-design-patterns-in-ruby/
• http://www.runtime-era.com/2012/12/basic-observer-design-pattern-in-ruby.html
• http://reefpoints.dockyard.com/2013/08/20/design-patterns-observer-pattern.html

作为一个软件工程师，拥有一些设计模式的知识总是会受欢迎的。如果你没有听过设计模式，他们基本上是开发者遇到的一些通用问题的可复用的解决方案。设计模式的列表很长，了解全部的设计模式是都非常困难的。好吧，困难或许不是一个很准确的词，但是要掌握全部的设计模式需要很多的实践。让我们来看看设计模式中最简单的一个——模板方法，并且用Ruby来实现它。

模板方法模式

模板方法模式定义了一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。模板方法是一种基于继承的代码复用技术，他是一种类行为模式。
模板方法模式是结构最简单的行为型设计模式，在其结构中只存在父类与子类之间的继承关系。通过使用模板方法模式，可以将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，从而使得相同的算法框架可以有不同的执行结果。模板方法模式提供了一个模板方法来定义算法框架，而某些具体步骤的实现可以在其子类中完成。

简单既是美

模板方法的优美之处在于它的简单性，但是关于它的定义却很冗长，导致你昏昏欲睡。通过将一系列的过程封装进不同的方法中来实现其行为的可配置性，使得子类可以覆写这些方法。下面是一个简单的例子：
Ruby Code:
class MagicCutter
def initialize vegetable
@vegetable = vegetable
end

  def give_me_the_vegetable_cutted_off
    prepapre_the_blade
    cut_the_vegetable
  end

  def prepapre_the_blade
    raise 'Called abstract method: prepapre_the_blade'
  end

  def cut_the_vegetable
    raise 'Called abstract method: cut_the_vegetable'
  end

end

框架方法是give_me_the_vegetable_cutted_off，它调用了一些列的方法，可以在子类中覆写这些方法使其拥有不同的行为。子类仅仅定义了那些将要改变的行为，覆写定义在框架类中的方法，但是give_me_the_vegetable_cutted_off不会被改变。让我们来看一下子类是如何实现的：
Ruby Code:
require_relative ‘magic_cutter’

class AubergineCutter < MagicCutter

  def prepapre_the_blade
    puts "Hey! that's a #{@vegetable}"
    puts "i need a very sharp knife"
  end

  def cut_the_vegetable
    puts "I slice the #{@vegetable}  in long thumbsized pieces, ready to be grilled"
  end

end

class PotatoCutter < MagicCutter

  def prepapre_the_blade
    puts "Hey! that's a #{@vegetable}"
    puts "i take a professional potato cutter for my french fries"
  end

  def cut_the_vegetable
    puts "put the #{@vegetable} in the cutter an press it"
  end

end

继承、方法覆写……这些看起来很熟悉，但是结果却令人满意。
Ruby Code:
au = AubergineCutter.new(“Aubergine”)
po = PotatoCutter.new(“Potato”)
au.give_me_the_vegetable_cutted_off
po.give_me_the_vegetable_cutted_off

钩子方法

通过观察上面的两个子类，可以发现puts “Hey! that’s a #{@vegetable}”被重复了两次，并且从来不会被改变。更进一步，可以发现PotatoCutter并没有定义对蔬菜进行剥皮的操作，这正是引入钩子方法的时刻。钩子方法允许在子类覆写框架的实现并且定义一些新的东西，或者继承其默认的实现。让我们通过一个例子来看一下如何实现钩子方法truly_excitement和prepare_the_vegetable。
Ruby Code:
class MagicCutter
def initialize vegetable
@vegetable = vegetable
end

  def give_me_the_vegetable_cutted_off
    truly_excitement
    prepapre_the_vegetable
    prepapre_the_blade
    cut_the_vegetable
  end

  def truly_excitement
    puts "Hey! that's a #{@vegetable}"
  end

  def prepapre_the_vegetable
  end

  def prepapre_the_blade
    raise 'Called abstract method: prepapre_the_blade'
  end

  def cut_the_vegetable
    raise 'Called abstract method: cut_the_vegetable'
  end

end

class PotatoCutter < MagicCutter

  def prepapre_the_vegetable
    puts "skin the potato"
  end

  def prepapre_the_blade
    puts "i take a professional potato cutter for my french fries"
  end

  def cut_the_vegetable
    puts "put the potato in the cutter an press it"
  end

end

c = PotatoCutter.new("Potato")
c.give_me_the_vegetable_cutted_off

class AubergineCutter < MagicCutter

  def prepapre_the_blade
    puts "i need a very sharp knife"
  end

  def cut_the_vegetable
    puts "I slice the #{@vegetable}  in long thumbsized pieces, ready to be grilled"
  end

end

c = AubergineCutter.new("Aubergine")
c.give_me_the_vegetable_cutted_off

这些钩子方法的默认实现通常是空的，他们的存在仅仅是为了告诉子类将要发生什么，但是不需要子类覆写不必要的方法。上面的例子中prepare_vegetable是一个空的方法，将留给子类来决定如何实现它。

一些需要注意的地方

模板方法越简单越好。
要避免写一个充满了方法的模板类，但是没有子类覆写这些方法，这会提高维护成本。
要避免提供过少的钩子，在某些时候，这就迫使子类不得不覆写整个方法。

参考资料：

• http://reefpoints.dockyard.com/ruby/2013/07/10/design-patterns-template-pattern.html
• http://edapx.com/2013/10/27/template-pattern/
• http://tammersaleh.com/posts/the-template-pattern-is-underused/

最近我写了一片关于模板方法模式以及怎样在Ruby中实现的文章。有读者在文章的评论中指出模板方法模式实际上是策略模式。在经过仔细的考虑该怎么回答这个问题在之后，我决定写一篇文章来比较这两个模式。

所以，在这里我将展示我对于设计模式的理解，让我们来看一下这两个模式之间的共同点以及二者之间的关键区别。

模板方法模式

关于这个模式需要记住的最重要的一点是：样板方法写在父类中，而特定的算法则在子类中实现(通常是覆盖)。也就是说，所有的子类都会共享父类的功能(继承)，但父类仅仅是一个框架类。另一方面来讲，子类只能复写特定于其领域的方法。

策略模式

策略模式的核心是将逻辑封装进对象中，使的在这些对象可以互换并将对象作为算法实现的一部分，也就是说算法的行为可以通过策略在运行时改变。

实现策略模式

让我们来通过下面的小例子看一下如何使用策略模式，首先创建一个简单的Invoice类：
Ruby Code:
class Invoice
attr_accessor :formatter

  def initialize amount, buyer, seller
    @amount = amount
    @buyer = buyer
    @seller = seller
    @formatter = JSONFormatter.new
  end

  def generate
    @formatter.format! @amount, @buyer, @seller
  end

end

就像你所看到的，发票包含数量，买家的名字，卖家的名字，在它的构造方法中，一个格式器被创建。格式器是一个拥有format！方法的类的实例，它将amount，buyer，seller作为参数。当该方法被调用，将会创建一个特定格式的Invoice对象。策略类的一个非常重要的方面是上下文类期望通过策略类来实现，在我们的例子中是format！方法。举例来讲，在Java它将通过接口来实现，它强迫实现类实现某些特定的方法。但是因为Ruby是一门动态语言，它没有接口之类的东西，这一点我们必须提前考虑到。

话虽这么说，还是让我们来看一看格式器类，它们都是非常简单的。
Ruby Code:
class JSONFormatter
def format! amount, buyer_name, seller_name
%Q{
{
“buyer” => “#{buyer_name}”,
“seller” => “#{seller_name}”,
“amount” => “#{amount}”
}
}
end
end
类JSONFormatter以JSON格式创建发票，说句题外话，我在这里用了百分比符号，通过这种形式使得代码拥有更好的可读性。
Ruby Code:
class XMLFormatter
def format! amount, buyer_name, seller_name
%Q{

#{buyer_name}
#{seller_name}
#{amount}

}
end
end
类XMLFormatter以XML格式创建发票。
Ruby Code:
class YAMLFormatter
def format! amount, buyer_name, seller_name

    %Q{
      ---
      invoice:
        buyer: #{buyer_name}
        seller: #{seller_name}
        amount: #{amount}
    }
  end
end

写在最后但并非不重要，类YAMLFormatter以YAML格式创建发票。策略模式的优美指出存在于上下文对象（Invoice对象）和策略(格式器)中。如你所见，当我们首先创建一个Invoice对象时，我们能够创建一个JSON格式的发票，这非常的酷。更酷的是你可以在运行时改变Invoice对象的行为，也就是说如果你改变了格式器对象，那么Invoice对象的行为也将改变。更抽象的将，上下文对象会随着赋予的每个不同的策略改变。那么怎样将其应用到我们的代码中呢？
Ruby Code:
invoice = Invoice.new 100, “John”, “Jane”
puts invoice.generate
我们第一次输出Invoice，采用JSONFormatter，当我们我们将得到一个JSON格式的发票。
Ruby Code:
{
“buyer” => “John”,
“cashier” => “Jane”,
“amount” => “100”
}
现在，如果我们对同一个Invoice对象采用不同的格式器……
Ruby Code:
invoice.formatter = XMLFormatter.new
puts invoice.generate
我们将得到同样的发票，不过是XML格式的。
Ruby Code:

John
Jane
100

如你所见，我们改变了格式器，Invoice对象的行为也改变了。

策略模式和模板方法模式

那么这二者之间的共同点和关键的不同之处是什么呢？我们你们其中的一些人已经很清楚了，另外一些人可能会很困惑（就像我最初一样）。二者都是将领域特定算法封装进对象中。最关键的区别在于策略模式通过策略在运行时改变上下文对象的行为，模板方法模式通过使用一个算法的框架实现，并且通过在框架的子类中覆写方法来改变其行为。

原文：

• http://rubylogs.com/pattern-to-pattern-template-method-and-strategy/

在这篇文章中，我将深入探讨Arrays。数组中有很多方法我们每天都用，但是也有一部分方法我们甚至不知道他们的存在。

基础

关于数组有一个非常无聊的定义，但是我们必须记住：数组的下标是从0开始的。一个负数下标表明从数组的最后开始计数–也就是说-1代表数组的最后一个数，-2代表倒数第2个数，以此类推。

那么问题来了,我们要怎样去创建一个数组呢？
Ruby code:
array = Array.new
=> []

或者
Ruby code:
array = []
=> []
数组可以包含各种类型的对象，整数、字符串、浮点数等-数组并不关心类型。
Ruby code:
array = [1, 2, “Super Mario”, 2.4, “Batman”, 100]
=> [1, 2, “Super Mario”, 2.4, “Batman”, 100]
或者

Ruby code:
Array.new(3)
=> [nil, nil, nil]
或者

Ruby code:
Array.new(3, true)
=> [true, true, true]
就像我们所熟知的，Ruby是一个完全的面向对象的语言，所以arrays也表现为对象。

探索的越深就越有趣

让我们从用的最多的迭代方法#each开始。这是一个我们过去见到过很多次并且在将来也会遇到很多次的方法。Array和Range类都有#each方法，通常#each会遍历每一个对象，并将其作为参数传入到block中，返回值为原始的集合。
Ruby code:
[1, 3, 4, 1, 2].each {|n| puts “#{n}! “}
1!
3!
4!
1!
2!
=> [1, 3, 4, 1, 2]
还有一个情况是如果想知道数组元素的位置，可以用#each_with_index。
Ruby code:
%w{Ruby is cool and provides us
with another syntax arrays}.each_with_index {|item, index| puts “position

#{index} for #{item}"}
position 0 for Ruby
position 1 for is
position 2 for cool
position 3 for and
position 4 for provides
position 5 for us
position 6 for with
position 7 for another
position 8 for syntax
position 9 for for
position 10 for arrays
 => ["Ruby", "is", "cool", "and", "provides",
     "us", "with", "another", "syntax", "for",
     "arrays"]

假设我们要区分偶数与基数，解决这个问题有许多种方法，但是#select是相对比较简洁的方法。
Ruby code:
%w{1 2 3 4 5 6 7 8 9 10 11 112 123 1432}.select { |num| num%2==0 }
=> []
但是结果并不是像我们预期的那样，为什么呢？答案是非常简单的，让我们先来看一看%w{1 2 3 4 5 6 7 8 9 10 11 112 123 1432}返回的是什么。
Ruby code:
%w{1 2 3 4 5 6 7 8 9 10 11 112 123 1432}
=> [“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “11”, “112”, “123”, “1432”]
问题很明显，我们不能对字符串应用除法运算，实际上我们不能对字符串做任何数学运算。
Ruby code:
%q => Single quoted string
%Q or % => Double quoted string
%w or %W => Array of tokens
%r => Regular Expression
%x => Shell Command
%i => Array of Symbols
为了避免这种情况让我们回到[...],这样就不会再次踩坑。
Ruby code:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 112, 123, 1432].select { |num| num%2==0 }
=> [2, 4, 6, 8, 10, 112, 1432]

没有数据操作我们将变成什么?举例来说，我们有很多用户，然后需要根据用户名来自动生成邮件地址，#map在这里将充当救世主的角色。
Ruby code:
users = [“Dalton Brown”, “Ralph Braun”, “Keara Mueller”, “Suzanne Schuppe”, “Trisha Batz”]
users.map { |user| user.downcase.tr(“ “, “_”) + “@your_site.com” }
得到的结果是：
Ruby code:
=> [“dalton_brown@your_site.com”, “ralph_braun@your_site.com”,
“keara_mueller@your_site.com”, “suzanne_schuppe@your_site.com”,
“trisha_batz@your_site.com”]

鲜为人知的方法

请记住#uniq和#uniq这两个方法之间的区别。#uniq返回一个去掉了重复元素的新数组，但是#uniq！会直接从原数组中删除重复的元素。
Ruby code:
example_array = [“x”, “z”, “z”, “z”, “a”, “b”, “b”]
> example_array.uniq
=> [“x”, “z”, “a”, “b”]
> example_array
=> [“x”, “z”, “z”, “z”, “a”, “b”, “b”]
和
Ruby code:
> example_array.uniq!
=> [“x”, “z”, “a”, “b”]
> example_array
=> [“x”, “z”, “a”, “b”]
你想要对数组中的元素进行分组么？那么#group将很适合你。
Ruby code:
users.group_by{|name| name.length}
=> {12=>[“Dalton Brown”], 11=>[“Ralph Braun”, “Trisha Batz”], 13=>[“Keara Mueller”], 15=>[“Suzanne Schuppe”]}
还有其它的一些非常有用的方法如|和 &。
Ruby code:
milan_colors = %w{red black}
liverpool_colors = %w{white red}
milan_colors | liverpool_colors
=> [“red”, “black”, “white”]
milan_colors & liverpool_colors
=> [“red”]
当然还不能忘了范围方法，我是这么称呼的~~
Ruby code:
2.1.2 :001 > a = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
2.1.2 :002 > a[0..-3]
=> [1, 2, 3]
2.1.2 :003 > a[0…-3]
=> [1, 2]
<<, +, 操作符和concat
Ruby code:
[1] << [2,3]
[1].concat([2,3])
[1] + [2,3]

#=> [1, [2, 3]]
#=> [1, 2, 3]
#=> [1, 2, 3]

参考资料：

• http://blog.diatomenterprises.com/arrays-are-the-workhorse-of-ruby/

#instance_eval和#instance_exec之间有一个非常重要的区别。Factory Girl是一个展示如何优雅的使用以上两者的很好的例子。

但是首先，在你急不可耐的准备构建令人惊奇的DSL之前，让我们来看一下#instance_eval是什么以及有什么作用。

最简单的例子来自于Ruby Docs:
Ruby Code:
class KlassWithSecret
def initialize
@secret = 99
end
end
k = KlassWithSecret.new
k.instance_eval { @secret } #=> 99

在提供的block中的self的当前值是调用#instance_eval的那个对象。所以，假设对象k是block的当前上下文；@secret是存储在k中的变量，#instance_eval打开了该对象的通道并且能够获取其所有的内部变量。

FactoryGirl提供的接口简单而直接，下面是一个来自于其”Getting Started”文档的例子。
Ruby Code:
FactoryGirl.define do
factory :user do
first_name “Kristoff”
last_name “Bjorgman”
admin false
end
end
在这里，Factory Girl使用#instance_eval来执行传递给factory的代码块。让我们通过一些富有表现力的代码来看一下FactoryGirl是怎么让这些工作起来的。
Ruby Code:
def factory(name, &block)
factory = Factory.new(name)
factory.instance_eval(&block) if block_given?

  # ... more code
end

实际上，这并不是来自于Factory Girl的代码， 但是它大致的说明了发生了什么。当#factory被调用时，一个新的Factory对象就被创建了，然后代码块就在该对象的上下文中执行。换句话讲，当你看到first_name时，就像看到该factory对象在前面，而不是factory.first_name。通过使用#instance_eval，Factory Girl的使用者不需要指定factory对象，它被隐式的添加。

好了，这一切都很好，但对于#instance_exec呢？我很高兴你问到了。

方法#instance_eval仅能评估(? evaluate~~怎么翻译好呢)代码块或者字符串，仅此而已。想要传递参数给代码块？你会遇到很大的麻烦。

但是#instance_exec不仅能够评估提供的代码块，还允许传递参数。让我们来看一个例子。

FactoryGirl允许通过使用回掉函数来执行一些动作，比如在对象创建之后。
Ruby Code:
FactoryGirl.define do
factory :user do
first_name “Kristoff”
last_name “Bjorgman”
admin false

    after(:create) do |user, evaluator|
      create_list(:post, evaluator.posts_count, user: user)
    end
  end
end

在这个例子中，after(:create)在对象创建之后执行，代码块接收了两个参数：user和evaluator。user参数是刚刚创建的user对象，evaluator参数存储了所有factory创建的所有的值。下面让我们来看一下这些是如何实现的。
Ruby Code:
def run(instance, evaluator)
case block.arity
when 1, -1 then syntax_runner.instance_exec(instance, &block)
when 2 then syntax_runner.instance_exec(instance, evaluator, &block)
else syntax_runner.instance_exec(&block)
end
end
FactoryGirl会创建一个以传递给after method的参数命名的callback。在该情形中，callback的名字是：create，同时还有一个代码块。

我们的例子中使用的代码块有两个参数。run方法决定怎样执行来自于代码块的代码。

callback对象存储了代码块，并且Ruby允许我们检查代码块的元数，换句话讲，它允许我们检查参数的数量。

当看case语句时，先检查else是一个好的主意，这会让你知道在没有匹配到任何代码的时候，when的部分会发生什么。接下来我们来看syntax_runner.instance_exec(&block),这可以很容易的被instance_eval代替。Ruby会在syntax_runner对象的上下文中评估或者执行代码块。

如果代码块的元数大于0，FactoryGirl会为对象提供一个代码块以便让这段代码符合我们的预期。case的第二部分检查代码块的元数是否等于2。
Ruby Code:
when 2 then syntax_runner.instance_exec(instance, evaluator, &block)
如果是，syntax_runner会接受一个实例对象(在我们的例子中是user)和evaluator。如果代码块的元数是1或者-1，代码块将仅接受一个instance参数。

那么-1代表什么呢？让我们来看一下怎么创建一个callback：
Ruby Code:

# Two arguments and arity of 2
after(:create) do |user, evaluator|
  create_list(:post, evaluator.posts_count, user: user)
end
# One argument and arity of 1
after(:create) do |user|
  create_group(:people, user: user)
end
# Zero arguments and arity of 0
after(:create) do
  puts "Yay!"
end
# Any arguments and arity of -1
after(:create) do |*args|
  puts "The user is #{args.first}"
end

通过*argsRuby并不知道你究竟会传递几个参数，所以Ruby干脆撒手不管，直接传回一个奇怪的数字-1。

这就是理解怎样和合何时使用instance_exec的力量，DSL用户会期望这些会有作用，事实上，确实会。

但是等一等，还有更多！如果你想为不同的属性指定同样的值呢？
Ruby Code:
FactoryGirl.define do
factory :user do
first_name “Kristoff”
last_name “Bjorgman”

    password "12345"
    password_confirmation "12345"
  end
end

在上面的例子中，password和password_confirmation拥有同样的值，这可能不怎么好。如果你改了其中的一个，而忘了了更改另外一个？当他们被绑定在实现中，二者的不一致可能会导致一些意想不到的错误。

我更愿意或许你也是，告诉FactoryGirl使用已经定义好的值。幸运的是，FiactoryGrl允许我们使用Ruby的一个小技巧#to_proc,下面展示了如何使用。
Ruby Code:
FactoryGirl.define do
factory :user do
first_name “Kristoff”
last_name “Bjorgman”

    password "12345"
    password_confirmation &:password
  end
end

重要的部分是传递给password_conformation的&：password值，Ruby看到&字符会将其视为代码块调用了to_proc方法。为了实现这个功能，FactoryGirl在属性上定义to_proc，并且使用instance_exec将符号password提供给代码块。
Ruby Code:
def to_proc
block = @block

  -> {
    value = case block.arity
            when 1, -1 then instance_exec(self, &block)
            else instance_exec(&block)
            end
    raise SequenceAbuseError if FactoryGirl::Sequence === value
    value
  }
end

那么对于lambda和proc呢？一些评论者在Reddit上提出了一个很重要的问题：关于#instance_eval和#instance_exec在分别传递lambda和proc的时候是如何表现的。

如果你传递一个lambda并且不提供参数，#instance_eval会出错。
Ruby Code:
object = Object.new
argless = ->{ puts “foo” }
object.instance_eval(&argless) #=> ArgumentError: wrong number of arguments (1 for 0)
之所以会出现这个错误，是因为Ruby会将当前对象作为self传递给block，解决方案是提供接受参数的lambda。
Ruby Code:
args = ->(obj){ puts “foo” }
object.instance_eval(&args) #=> “foo”
如果使用#instance_exec将会有点小变化。
Ruby Code:
object.instance_exec(&argless) #=> “foo”
object.instance_exec(&args) #=> ArgumentError: wrong number of arguments (0 for 1)
object.instance_exec(“some argument”, &args) #=> “foo”
因为proc在参数校验方面不是那么严格，所以以上两种尝试都不会导致错误。
Ruby Code:
p_argless = proc{ puts “foo” }
object.instance_eval(&p_argless) #=> “foo”

p_args = proc{|obj| puts "foo" }
object.instance_eval(&p_args) #=> "foo"

object.instance_exec(&p_args) #=> "foo"
object.instance_exec(&p_argless) #=> "foo"

现在你知道了#instance_eval和#instance_exec在表现方式上是类似的，如果你需要传递参数，那么请使用#instance_exec。

原文：

• http://www.saturnflyer.com/blog/jim/2015/04/22/the-difference-between-instance_eval-and-instance_exec/

前端开发中，CSS居中一直是一个令人头痛的问题。为什么CSS居中这么困难呢？其实实现CSS居中并不难，难的是如何从众多的CSS居中方法中选择一个合适的解决方案，通常你并不知道那种解决方案适合当前的情形。所以，让我们来整理一个决策树，希望能够帮助大家更容易的解决CSS居中的问题。

一.水平居中

# 1.是否是 inline或者inline-*元素

将inline元素放置在block父元素中，然后给父元素加上text-align: center;

HTML:
<header>
  This text is centered.
</header>

<nav role='navigation'>
  <a href="#0">One</a>
  <a href="#0">Two</a>
  <a href="#0">Three</a>
  <a href="#0">Four</a>
</nav>

CSS:
body {
background: #f06d06;
}

header, nav {
  text-align: center;
  background: white;
  margin: 20px 0;
  padding: 10px;
}

nav a {
  text-decoration: none;
  background: #333;
  border-radius: 5px;
  color: white;
  padding: 3px 8px;
}

# 2.是否是block元素

可以利用margin:0 auto;来实现水平居中，利用这种技术的前提是该元素拥有一个固定的宽度。
HTML:

I’m a block level element and am centered.

CSS:
body {
background: #f06d06;
}

main {
  background: white;
  margin: 20px 0;
  padding: 10px;
}

.center {
  margin: 0 auto;
  width: 200px;
  background: black;
  padding: 20px;
  color: white;
}

# 3.是否有多个block元素需要居中

如果你有多种block级别的元素需要在一行中水平居中，那么你最好赋予这些元素的display属性不同的值。

HTML:

I’m an element that is block-like with my siblings and we’re centered in a row.

I’m an element that is block-like with my siblings and we’re centered in a row. I have more content in me than my siblings do.

I’m an element that is block-like with my siblings and we’re centered in a row.

I’m an element that is block-like with my siblings and we’re centered in a row.

I’m an element that is block-like with my siblings and we’re centered in a row. I have more content in me than my siblings do.

I’m an element that is block-like with my siblings and we’re centered in a row.

CSS:
body {
background: #f06d06;
font-size: 80%;
}

main {
  background: white;
  margin: 20px 0;
  padding: 10px;
}

main div {
  background: black;
  color: white;
  padding: 15px;
  max-width: 125px;
  margin: 5px;
}

.inline-block-center {
  text-align: center;
}
.inline-block-center div {
  display: inline-block;
  text-align: left;
}

.flex-center {
  display: flex;
  justify-content: center;
}

二.垂直居中

相对而言，CSS垂直居中的实现更加的复杂一点。

#1.是否是inline或者inline-*元素

• 需要居中的元素是否只有一行?
  有时候赋予元素相等的上下内边距就可以实现元素的垂直居中。
  HTML:

  <main>
    <a href="#0">We're</a>
    <a href="#0">Centered</a>
    <a href="#0">Bits of</a>
    <a href="#0">Text</a>
  </main>
  

  CSS:

  body {
    background: #f06d06;
    font-size: 80%;
  }
  
  main {
    background: white;
    margin: 20px 0;
    padding: 50px;
  }
  
  main a {
    background: black;
    color: white;
    padding: 40px 30px;
    text-decoration: none;
  }
  

  如果padding的解决方案不能满足要求，并且需要居中的文字不会被包裹，那么可以设置line-height和height的值相等。

HTML:

I’m a centered line.

CSS:
body {
background: #f06d06;
font-size: 80%;
}

main {
  background: white;
  margin: 20px 0;
  padding: 40px;
}

main div {
  background: black;
  color: white;
  height: 100px;
  line-height: 100px;
  padding: 20px;
  width: 50%;
  white-space: nowrap;
}

• 需要居中的元素是否有多行？
  设置相同的上下内边距同样可以让多行的inline元素居中，如果这种技术不能够实现居中，可以采用display:table-cell;来实现垂直居中。
  HTML:

  <table>
    <tr>
      <td>
        I'm vertically centered multiple lines of text in a real table cell.
     </td>
    </tr>
  </table>
  
  <div class="center-table">
    <p>I'm vertically centered multiple lines of text in a CSS-created table layout.</p>
  </div>
  

  CSS:

  body {
    background: #f06d06;
    font-size: 80%;
  }
  
  table {
    background: white;
    width: 240px;
    border-collapse: separate;
    margin: 20px;
    height: 250px;
  }
  
  table td {
    background: black;
    color: white;
    padding: 20px;
    border: 10px solid white;
    /* default is vertical-align: middle; */
  }
  
  .center-table {
    display: table;
    height: 250px;
    background: white;
    width: 240px;
    margin: 20px;
  }
  .center-table p {
    display: table-cell;
    margin: 0;
    background: black;
    color: white;
    padding: 20px;
    border: 10px solid white;
    vertical-align: middle;
  }
  

  另外的一种实现垂直居中的方案是采用display:flex;这种方案相对来讲也比较简单。利用flex-box方案需要父容器有一个固定的高度。
  HTML:

  <div class="flex-center">
    <p>I'm vertically centered multiple lines of text in a flexbox container.</p>
  </div>
  

  CSS:

  body {
      background: #f06d06;
      font-size: 80%;
  }
  
  div {
      background: white;
      width: 240px;
      margin: 20px;
   }
  
  .flex-center {
      background: black;
      color: white;
      border: 10px solid white;
      display: flex;
      flex-direction: column;
      justify-content: center;
      height: 200px;
      resize: vertical;
      overflow: auto;
  }
  .flex-center p {
      margin: 0;
      padding: 20px;
  }
  

  如果以上方案都不能满足要求，可以尝试采用”Goast Element”技术，该技术在容器中放置一个100%高度的伪元素来实现目标元素的居中。
  HTML:

  <div class="ghost-center">
    <p>I'm vertically centered multiple lines of text in a container. Centered with a ghost pseudo element</p>
  </div>
  

  CSS:

  body {
    background: #f06d06;
    font-size: 80%;
  }
  
  div {
    background: white;
    width: 240px;
    height: 200px;
    margin: 20px;
    color: white;
    resize: vertical;
    overflow: auto;
    padding: 20px;
  }
  
  .ghost-center {
    position: relative;
  }
  .ghost-center::before {
    content: " ";
    display: inline-block;
    height: 100%;
    width: 1%;
    vertical-align: middle;
  }
  .ghost-center p {
    display: inline-block;
    vertical-align: middle;
    width: 190px;
    margin: 0;
    padding: 20px;
    background: black;
  }
  

  #2.是否是block元素

• 元素高度已知
  大多数情况下我们并不知道需要居中的元素的高度，原因有很多，这里不赘述。倘若你知道元素的高度，那么可以利用如下的方法实现block元素的垂直居中。

HTML:

  <div>
     I'm a block-level element with a fixed height, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
}

main {
  background: white;
  height: 300px;
  margin: 20px;
  width: 300px;
  position: relative;
  resize: vertical;
  overflow: auto;
}

main div {
  position: absolute;
  top: 50%;
  left: 20px;
  right: 20px;
  height: 100px;
  margin-top: -70px;
  background: black;
  color: white;
  padding: 20px;
}

• 元素的高度未知

HTML:

  <div>
     I'm a block-level element with an unknown height, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
}

main {
  background: white;
  height: 300px;
  margin: 20px;
  width: 300px;
  position: relative;
  resize: vertical;
  overflow: auto;
}

main div {
  position: absolute;
  top: 50%;
  left: 20px;
  right: 20px;
  background: black;
  color: white;
  padding: 20px;
  transform: translateY(-50%);
  resize: vertical;
  overflow: auto;
}

# 3.是否可以使用flex-box

HTML:

  <div>
     I'm a block-level element with an unknown height, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
}

main {
  background: white;
  height: 300px;
  width: 200px;
  padding: 20px;
  margin: 20px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  resize: vertical;
  overflow: auto;
}

main div {
  background: black;
  color: white;
  padding: 20px;
  resize: vertical;
  overflow: auto;
}

三.水平居中和垂直居中

可以组合前文提到的方案来实现元素的水平和垂直居中，下面给出三种比较常见的组合。

# 1.元素的宽度和高度固定

使用负边距来定位，左右负边距设置为宽度的一半，上下负边距设定为高度的一半，这种方案的兼容性很好。

HTML:

  <div>
     I'm a block-level element a fixed height and width, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
padding: 20px;
}

main {
  position: relative;
  background: white;
  height: 200px;
  width: 60%;
  margin: 0 auto;
  padding: 20px;
  resize: both;
  overflow: auto;
}

main div {
  background: black;
  color: white;
  width: 200px;
  height: 100px;
  margin: -70px 0 0 -120px;
  position: absolute;
  top: 50%;
  left: 50%;
  padding: 20px;
}

#2.元素的宽度和高度未知。

如果元素的高度和宽度未知，那么可以利用transform属性来实现。

HTML:

  <div>
     I'm a block-level element of an unknown height and width, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
padding: 20px;
}

main {
  position: relative;
  background: white;
  height: 200px;
  width: 60%;
  margin: 0 auto;
  padding: 20px;
  resize: both;
  overflow: auto;
}

main div {
  background: black;
  color: white;
  width: 50%;
  transform: translate(-50%, -50%);
  position: absolute;
  top: 50%;
  left: 50%;
  padding: 20px;
  resize: both;
  overflow: auto;
}

# 3.是否可以使用flex-box

HTML:

  <div>
     I'm a block-level-ish element of an unknown width and height, centered vertically within my parent.
  </div>

</main>

CSS:
body {
background: #f06d06;
font-size: 80%;
padding: 20px;
}

main {
  background: white;
  height: 200px;
  width: 60%;
  margin: 0 auto;
  padding: 20px;
  display: flex;
  justify-content: center;
  align-items: center;
  resize: both;
  overflow: auto;
}

main div {
  background: black;
  color: white;
  width: 50%;
  padding: 20px;
  resize: both;
  overflow: auto;
}

参考资料：

• https://css-tricks.com/centering-css-complete-guide/

build_stubbed是在FactoryGirl中引入的一个方法，build_stubbed和build都是用来创建实例并分配属性。区别是build_stubbed使得对象看起来像是被持久化了，实际上并没有。它采用build_stubbed策略来创建关联，并且提供了少量的同数据库进行交互的方法，如果调用他们，这些方法会被触发。通过这种策略，可以加快测试的速度，同时减少对数据库的依赖。

但是如果创建的对象有关联的对象的话，被关联的对象是会被持久化到数据中的。为了避免这一情况的
发生可以将不必要的的关联设置为nil。
Ruby Code:
assoiation :store
assoiation :area

FactoryGirl.build_stubbed(:store, company: fg_company, area: nil)

通过这种方式就不会额外的创建被关联的数据了。如果创建时有很多依赖，但是你忘记了将其中的一个
或者几个关联设置为nil，同样会往数据库中写入很多数据。这里给出解决方案：

1. 在FactoryGirl的定义中手动的删除assoiation。

2. 将所有的实例变量移入before(:all)代码块中。
   Ruby Code:
   before(:all) do
   @company = FactoryGirl.build_stubbed(:company)
   @store = FactoryGirl.build_stubbed(:store, company: company)
   end
   或者采用下面的方案：
   Ruby Code:
   factory :post do
   title # sequence
   author # sequence, so the example is shorter

   stuff

   after(:build) {|p| p.comments ||= create_list(:comment, 5, post: p) }
   after(:stub) {|p| p.comments ||= build_stubbed_list(:comment, 5, post: p}
   end

   create(:post) # with auto comments
   create(:post, comments: some_other_comments) # with comments for a specific test
   build_stubbed(:post) # with auto comments and no DB
   build_stubbed(:post, comments: []) # a post with no comments, still not touching the DB
   这种用法使得before(:all)仅仅被用作提供事物功能的一个骨架。这就导致了测试状态更加的依赖测试的顺序，这是应该避免的。当然，也可以通过在before/after :all 代码块中加入清除数据的逻辑来解决。

参考资料：

• http://blog.spoolz.com/2012/07/09/small-revelation-factorygirl-build_stubbed-associations-and-let/
• https://robots.thoughtbot.com/use-factory-girls-build-stubbed-for-a-faster-test