Y a-t-il une différence dans l'utilisation de `yield self` dans une méthode avec les paramètres` & block` et `yield self` dans une méthode sans paramètre` & block`?

Question

Je comprends que

def a(&block) 
    block.call(self) 
end 

et

def a() 
    yield self 
end 

conduisent au même résultat, si je suppose qu'il ya un tel bloc a {}. Ma question est - depuis que je suis tombé sur un code comme ça, si cela fait une différence ou s'il y a un avantage d'avoir (si je ne pas utiliser la variable/bloc de référence autre):

def a(&block) 
    yield self 
end 

C'est cas concret où je ne comprends pas l'utilisation de &block:

def rule(code, name, &block) 
    @rules = [] if @rules.nil? 
    @rules << Rule.new(code, name) 
    yield self 
end 

Answer 1

l'avantage que je peux penser est à l'introspection:

def foo;  end 
def bar(&blk); end 

method(:foo).parameters #=> [] 
method(:bar).parameters #=> [[:block, :blk]] 

IDEs et documentation les générateurs pourraient en profiter. Cependant, cela n'affecte pas l'argument de Ruby. Lorsque vous appelez une méthode, vous pouvez passer ou omettre un bloc, qu'il soit déclaré ou invoqué.

Answer 2

La principale différence entre

def pass_block 
    yield 
end 
pass_block { 'hi' } #=> 'hi' 

et

def pass_proc(&blk) 
    blk.call 
end 
pass_proc { 'hi' } #=> 'hi' 

est que, blk, une instance de Proc, est un objet et peut donc être transmis à d'autres méthodes. En revanche, les blocs ne sont pas des objets et ne peuvent donc pas être transmis.

def pass_proc(&blk) 
    puts "blk.is_a?(Proc)=#{blk.is_a?(Proc)}" 
    receive_proc(blk) 
end 

def receive_proc(proc) 
    proc.call 
end 

pass_proc { 'ho' } 
blk.is_a?(Proc)=true 
    #=> "ho"