À l'aide de faire bloc vs accolades {}

C'est un peu vieux, mais je voudrais essayer d'expliquer un peu plus sur {} et do .. end

comme il est dit avant

support de la syntaxe a une priorité plus élevée afin de faire..fin

mais comment celui-ci fait la différence:

method1 method2 do
  puts "hi"
end

dans ce cas, method1 sera appelée avec le bloc de do..end et method2 sera transmis à method1 comme argument! ce qui est équivalent à method1(method2){ puts "hi" }

mais si vous dites

method1 method2{
  puts "hi"
}

puis method2 seront appelés avec le bloc alors la valeur retournée sera transmis à method1 comme argument. Ce qui est équivalent à method1(method2 do puts "hi" end)

def method1(var)
    puts "inside method1"
    puts "method1 arg = #{var}"
    if block_given?
        puts "Block passed to method1"
        yield "method1 block is running"
    else
        puts "No block passed to method1"
    end
end

def method2
    puts"inside method2"
    if block_given?
        puts "Block passed to method2"
        return yield("method2 block is running")
    else
        puts "no block passed to method2"
        return "method2 returned without block"
    end
end

#### test ####

method1 method2 do 
    |x| puts x
end

method1 method2{ 
    |x| puts x
}

#### sortie ####

#inside method2
#no block passed to method2
#inside method1
#method1 arg = method2 returned without block
#Block passed to method1
#method1 block is running

#inside method2
#Block passed to method2
#method2 block is running
#inside method1
#method1 arg = 
#No block passed to method1

Il y a deux styles pour choisir do end vs { } pour les blocs en Ruby:

Le premier et très bon style a été popularisé par Ruby on Rails, et est basé sur une règle simple de simple contre multi-ligne:

• Utiliser des accolades { } pour une seule ligne de blocs
• Utilisation do end pour le multi-blocs de lignes

Cela a un sens parce que faire/fin de lit mal dans un one-liner, mais pour le multi-blocs de lignes, en laissant une clôture } accroché sur sa propre ligne est incompatible avec tout le reste qui utilise end en ruby, telles que le module, classe & les définitions de méthode (def etc.) et des structures de contrôle (if, while, case, etc.)

La deuxième, moins fréquemment vu le style est connu comme la sémantique, ou "Weirich Accolades", proposé par la fin, une grande rubyist Jim Weirich:

• Utilisation do end de procédure blocs
• Utiliser des accolades { } pour les blocs fonctionnels

Cela signifie que lorsque le bloc est évalué pour son valeur de retour, il devrait être chainable, et la {} accolades plus de sens pour le chaînage de méthode.

D'autre part, lorsque le bloc est évalué pour son effets secondaires, alors la valeur de retour est sans conséquence, et le bloc est juste "faire" quelque chose, de sorte qu'il ne fait pas de sens d'être enchaînés.

Cette distinction dans la syntaxe transmet visual sens au sujet de l'évaluation de la bloquer, et si oui ou non vous devriez vous préoccuper de sa valeur de retour.

Par exemple, ici, la valeur de retour du bloc est appliqué à chaque élément:

items.map { |i| i.upcase }

Cependant, ici, il n'est pas en utilisant le bloc de valeur de retour. Il fonctionne sur le plan procédural, et faire un des effets secondaires avec elle:

items.each do |item|
  puts item
end

Un autre avantage de la sémantique du style, c'est que vous n'avez pas besoin de changer des accolades à faire/à la fin juste parce qu'une ligne a été ajoutée au bloc.

Comme une observation, comme par hasard fonctionnelle blocs sont souvent un one-liner, et de procédure blocs (par exemple config) sont multi-ligne. Ainsi, à la suite de la Weirich style finit par regarder presque la même que les Rails de style.