1.Block:

　　Ruby中的块就是由多行代码组成的一个代码块，通常可以把它认为是一个匿名方法，常用来迭代一个数组或范围(如each, times方法)；语法格式如下:

　　{            

        　　//code

　　}            

OR

　　do          

        　　//code

　　end         

　　块变量：当创建一个块时，在两个竖线之间(如: | i |)被称作块变量，作用和一个正常方法的参数一样；如：5.each{| x |  puts x } 

2.Block and Array

Block常用来迭代数组，上面也提到过，所以数组中也定义了很多方法接受块参数；常用的有:

　　collect：该方法把数组的每一个元素传给块并返回一个新的包括所有元素的数组，原数组的值不变。如果使用collect！方法刚会修改原数组的值；

　　each：each方法和collect方法有点类似，会把数组的每个元素的值传递给块，但和collect不同的是，each方法不会创建一个新的包含返回值的数组；没有each!方法；

例：

　　a = [1,2,3]

　　b = a.collect{|x| x*2}

　　puts("-a-")

　　puts a

　　puts("-b-")

　　puts b

　　c = a.collect!{|x| x*2}

　　puts("-a-")

　　puts a

--------------result------------------

　　-a-

　　1

　　3

　　-b-

　　2

　　6

　　-a-

　　2

　　6

       另外，我们怎么迭代一个字符串中的每一个字符？我们首先要做的是用split方法分割字符串，然后再进行迭代；

例：

　　a = "hello".each{|x| puts x}

　　a = "hello".split (//).each{|x| puts x}

　　-------------------result-------------------------------

     hello

　　h

　　e

　　l

　　l

　　o 

Block在Ruby在有些特别，因为block变不是对象，这与ruby中”一切皆对象”不符合；每一个对象都创建于一个类，我们可以使用class方法来找到某个对象属于哪个类；

例：

　　puts( { 1=>2 }.class )                      #Hash

　　puts( {|x| puts(x) }.class                  #error

3.Proc and Lambda

虽然block默认并不是对象，它们可以”变成”对象。有三种方法用于从block创建对象并把它们分配给变量，格式如下：

　　a = Proc.new{ |x| puts x }

　　b = lambda{ |x| puts x }

　　c = proc{ |x| puts x }

　　让我们分别来看一下这三种创建方法；首先，我们可以用Proc.new来创建一个对象并且把一个block作为参数传递给它； 然后，我们可以使用Proc类的call(可以传递一个或多个参数给call方法，这些参数会传递到block里，参数个数取决于block中参数的个数)方法来执行block中的代码；

　　我们也可以使用其它两种方法创建一个Proc对象，三种方法都差不多；唯一的区别就是用Proc.new创建的对象不会检查参数的数量，其它两种方法会check;

例：

       a = Proc.new{|x,y,z| x=y*z; puts x}

　　a.call(10,20,30,40)                                        #=>600

　　b = proc{|x,y,z| x=y*z; puts x}

　　b.call(10,20,30,40)                                        #=>error

　　c = lambda{|x,y,z| x=y*z; puts x}

　　c.call(10,20,30,40)                                        #=>error

4.Yield

在Ruby中可以把block当作参数传递给方法，方法里面再使用yield(可以传递参数)关键字调用代码块；

例1：不带参数

       class  Person

              def go()

                     yield

              end

       end

      p = Person.new

　　p.go {puts("hello world")}

　　Note：我们只是简单的把block放在我们想传递进去的方法的右边，方法接收block，当执行到yield时就会调用block的代码；

例2：带参数

　　class  Person

　　　　def go(spead)

　　　　　　yield(spead)

　　　　end

　　end

　　p = Person.new

　　p.go("ten miles per hour!") {|x| x.capitalize! puts x}

      Note：

　　1.在些例中，go方法带有一个参数，spead，并且把这个参数传递到被yield执行的block里面；当调用go方法时，我传递了一个参数(“ten miles per hour!”)，当执行到yield语句时，会传递给block参数；

      2.使用yield关键字调用代码块时，如果传入的参数个数少于代码块中定义的参数个数，那么没有传递的参数会自动转为nil。反之，那么最后一个参数为一个数组，该数组包含了剩余的传递参数；

5.传递命名的Proc对象

　　在Ruby中定义方法时，如果在方法的最后一个形参前增加一个”&”符号，那么Ruby会把这个形参作为一个Proc对象处理(例2)；而Proc对象实际上就是一个代码块的封装体，因此在调用方法时需要传递一个block作为参数；

例1：

       def abc( a, b, c )

　　　　a.call            #<= call block a

　　　　b.call            #<= call block b

　　　　c.call            #<= call block c

　　　　yield            #<= yield unnamed block: { puts "four" }

　　end

　　abc(a, b, c ){ puts "four" }

例2：

　　def test( &a )

　　　　a.call             #<= block &d yield

　　　　yield              #<= also block &d

　　end

　　test{ puts "hello" }                   #法一，传递一个块

      a = proc{puts "world"}

　　test(&a)                                    #法二，传递一个Proc对象

6.程序优先级

　　在传递一个block时，使用｛｝传递的block比使用do…end的优先级要高；为了避免引起歧义，最好使用大括号将参数括起来；

　　1. foo bar do…end：传递到foo方法里面，bar会作为一个参数传递给foo  

　　2. foo bar {…}：block会传递到bar里面，返回的值会作为参数传递给方法foo

例：

       def foo( b )

              puts("---in foo---")

              a = 'foo'

              if block_given?

                     puts( "(Block passed to foo)" )

                    yield( a )

              else

                     puts( "(no block passed to foo)" )

              end

              puts( "in foo, arg b = #{b}" )

              return "returned by " << a

　　end

　　def bar

              puts("---in bar---")

              a = 'bar'

              if block_given?

                     puts( "(Block passed to bar)" )

                     yield( a )

              else

                     puts( "(no block passed to bar)" )

              end

              return "returned by " << a

　　end

　　# ========== Syntax "A" - do..end =======

　　puts( '--- (A) do block ---' )

　　# calls foo with block

　　foo bar do |s| puts( s ) end

　　# the above is equivalent to

　　# foo( bar ) do |s| puts( s ) end

　　#    or

　　# foo( bar ) { |s| puts(s) }

　　puts

　　# ========== Syntax "B" - {} =======

　　puts( '--- (B) curly braces block ---' )

　　# calls bar with block

　　foo bar{ |s| puts(s) }

　　------------------------result----------------------------------

　　--- (A) do block ---

　　---in bar---

　　(no block passed to bar)

　　---in foo---

　　(Block passed to foo)

　　foo

　　in foo, arg b = returned by bar

　　--- (B) curly braces block ---

　　---in bar---

　　(Block passed to bar)

　　bar

　　---in foo---

　　(no block passed to foo)

　　in foo, arg b = returned by bar

　　Note：我们可以使用block_given?方法来判定一个方法是否接收了一个block；