Понимание Ruby Блоков, Проков и лямбда-выражений.

Understanding Ruby Blocks, Procs and Lambdas

Blocks, Procs and lambdas (referred to as closures in Computer Science) are one of the most powerful aspects of Ruby, and also one of the most misunderstood. This is probably because Ruby handles closures in a rather unique way. Making things more complicated is that Ruby has four different ways of using closures, each of which is a tad bit different, and sometimes nonsensical. There are quite a few sites with some very good information about how closures work within Ruby. But I have yet to find a good, definitive guide out there. Hopefully, this tutorial becomes just that.

First Up, Blocks

The most common, easiest and arguably most “Ruby like” way to use closures in Ruby is with blocks. They have the following familiar syntax:

array = [1, 2, 3, 4]
array.collect! do |n|
n ** 2
end

puts array.inspect # => [1, 4, 9, 16]

So, what is going on here?

1. First, we send the collect! method to an Array with a block of code.

2. The code block interacts with a variable used within the collect! method (n in this case) and squares it.

3. Each element inside the array is now squared.

Using a block with the collect! method is pretty easy, we just have to think that collect! will use the code provided within the block on each element in the array. However, what if we want to make our own collect! method? What will it look like? Well, lets build a method called iterate! and see.

class Array

def iterate!
self.each_with_index do |n, i
self[i] = yield(n)
end
end
end

array = [1, 2, 3, 4]

array.iterate! do |n|
n ** 2
end

puts array.inspect # => [1, 4, 9, 16]

To start off, we re-opened the Array class and put our iterate! method inside. We will keep with Ruby conventions and put a bang at the end, letting our users know to watch out, as this method might be dangerous! We then use our iterate! method just like Ruby’s built in collect! method. The neat stuff however, is right in the middle of our iterate! method definition.

Unlike attributes, you do not need to specify the name of blocks within your methods. Instead, you can use the yield keyword. Calling this keyword will execute the code within the block provided to the method. Also, notice how we are passing n (the integer that the each_with_index method is currently working with) to yield. The attributes passed to yield corresponds to the variable specified in the piped list of the block. That value is now available to the block and returned by the yield call. So to recap what is happening: