Ruby：如何创建一个块并将其作为参数传递？

Question

I'm working with a method that takes a block as an argument. I'm new to Ruby and Blocks, so I don't quite understand how I would go about creating a Block and passing it to the method. Can you please provide me an example of how you would create a block and pass it as an argument?

Update: Here is an example of the method that I am trying to call:

def exec!(commands, options=nil, &block)
  # method code here
  # eventually it will execute the block if one was passed
end

Here is how I am currently calling this method:

@result = ssh.exec!("cd /some/dir; ls")

How do I pass a block as the third argument to the exec! method?

Answer 1

It depends partially on how you want to use it. An easy way is this, if it fits your usage needs:

@result = ssh.exec!("cd /some/dir; ls") do |something|
    # Whatever you need to do
    # The "something" variable only makes sense if exec! yields something
end

Or

@result = ssh.exec!("cd /some/dir; ls") { |something| puts something }

The {} notation is generally used when the block is short.

You can also create a Proc or lambda; ultimately the "right" answer depends on what you're trying to do.

Note there's an example if you're talking about Net::SSH.

Answer 2

And one more thing. You can also create Proc-object (or any object that have 'to_proc' method) and call your method with that Proc-object as last argument with '&' symbol before it. For example:

proc = Proc.new { |x| puts x }
%w{1 2 3}.each(&proc)

other way to doing the same thing:

%w{1 2 3}.each { |x| puts x }

Answer 3

How about using keyword yield for understanding the passing block argument?

For example we have:

def our_method
  puts "we're going to call yield operator"
  yield "this is message from our_method"
  puts "we called the yield operator"
end

our_method { |message| puts message }

We will get this result:

we're going to call yield operator
this is message from our_method
we called the yield operator

How it works?

When we called the our_method we also passed to it the argument, in our case it's a block -

{ |message| puts message } { |message| puts message } .

In the our_method it executes first string and will print "we're going to call yield operator" .

And then it's the turn of yield operator. It almost equivalent to block.call but besides this it's passing the message to the block as an argument. That's why the block will print string from our_method.

In the end the our_method prints final string "we called the yield operator" .