Verwenden von do block vs klammern {}

Neu bei Ruby, zieh deine Newbie-Handschuhe an.

Gibt es einen Unterschied (dunkel oder praktisch) zwischen den folgenden beiden Ausschnitten?

my_array = [:uno, :dos, :tres]
my_array.each { |item| 
    puts item
}

my_array = [:uno, :dos, :tres]
my_array.each do |item| 
    puts item
end

Mir ist klar, dass Sie mit der Klammer-Syntax den Block in einer Zeile platzieren können

my_array.each { |item| puts item }

Aber gibt es darüber hinaus zwingende Gründe, eine Syntax über die andere zu verwenden?

Laut Ruby-Kochbuch hat die Klammernsyntax eine höhere Rangfolge alsdo..end

Beachten Sie, dass die Klammernsyntax eine höhere Priorität hat als die do..end-Syntax. Betrachten Sie die folgenden zwei Codeausschnitte:

1.upto 3 do |x|
  puts x
end

1.upto 3 { |x| puts x }
# SyntaxError: compile error

Das zweite Beispiel funktioniert nur, wenn Klammern verwendet werden. 1.upto(3) { |x| puts x }

Dies ist eine etwas alte Frage, aber ich möchte versuchen, etwas mehr über {}und zu erklärendo .. end

wie es schon gesagt wird

Die Klammer-Syntax hat eine höhere Rangfolge als do..end

aber wie macht dieser Unterschied:

method1 method2 do
  puts "hi"
end

In diesem Fall wird Methode1 mit dem Block von do..endaufgerufen und Methode2 wird als Argument an Methode1 übergeben! das ist äquivalent zumethod1(method2){ puts "hi" }

aber wenn du sagst

method1 method2{
  puts "hi"
}

dann wird method2 mit dem Block aufgerufen, dann wird der zurückgegebene Wert als Argument an method1 übergeben. Welches ist gleichbedeutend mitmethod1(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
}

#### Ausgabe ####

#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

Im Allgemeinen wird die Konvention verwendet, {}wenn Sie eine kleine Operation ausführen, z. B. einen Methodenaufruf oder einen Vergleich usw., sodass dies durchaus sinnvoll ist:

some_collection.each { |element| puts element }

Wenn Sie jedoch eine etwas komplexe Logik haben, die mehrere Zeilen umfasst, verwenden Sie do .. endFolgendes:

1.upto(10) do |x|
  add_some_num = x + rand(10)
  puts '*' * add_some_num
end

Grundsätzlich kommt es darauf an, ob Ihre Blocklogik mehrere Zeilen umfasst und nicht in dieselbe Zeile eingepasst werden kann, do .. endund wenn Ihre Blocklogik einfach ist und nur eine einfache / einzelne Codezeile verwendet wird {}.

In Ruby gibt es zwei gängige Stile für die Auswahl im do endVergleich { }zu Blöcken:

Der erste und sehr verbreitete Stil wurde von Ruby on Rails populär gemacht und basiert auf einer einfachen Regel von ein- oder mehrzeilig:

• Verwenden Sie geschweifte Klammern { }für einzeilige Blöcke
• Verwendung do endfür mehrzeilige Blöcke

Dies ist sinnvoll, da do / end in einem Einzeiler schlecht gelesen wird. Bei mehrzeiligen Blöcken ist es jedoch nicht konsistent, einen Abschluss }in einer eigenen Zeile hängen zu lassen, was endin Ruby verwendet wird, z. B. Modul-, Klassen- und Methodendefinitionen ( defusw.) .) und Kontrollstrukturen ( if, while, case, etc.)

Der zweite, weniger häufig gesehene Stil ist als semantische oder " Weirich Braces " bekannt, die vom verstorbenen, großen Rubinisten Jim Weirich vorgeschlagen wurde:

• Verwendung do endfür Verfahrensblöcke
• Verwenden Sie Klammern { }für Funktionsblöcke

Dies bedeutet, dass der Block, wenn er auf seinen Rückgabewert bewertet wird , verkettbar sein sollte und die {}geschweiften Klammern für die Methodenverkettung sinnvoller sind.

Auf der anderen Seite, wenn der Block für seine ausgewertet wird Nebenwirkungen untersucht wird , hat der Rückgabewert keine Konsequenz, und der Block "tut" nur etwas, so dass es keinen Sinn macht, verkettet zu werden.

Diese Unterscheidung in der Syntax vermittelt eine visuelle Bedeutung für die Auswertung des Blocks und ob Sie sich um seinen Rückgabewert kümmern sollten oder nicht.

Hier wird beispielsweise der Rückgabewert des Blocks auf jedes Element angewendet:

items.map { |i| i.upcase }

Hier wird jedoch nicht der Rückgabewert des Blocks verwendet. Es arbeitet prozedural und dabei einen Nebeneffekt mit sich:

items.each do |item|
  puts item
end

Ein weiterer Vorteil des semantischen Stils besteht darin, dass Sie keine geschweiften Klammern für do / end ändern müssen, nur weil dem Block eine Zeile hinzugefügt wurde.

Als Beobachtung sind zufällig funktionale Blöcke häufig einzeilig , und prozedurale Blöcke (z. B. config) sind mehrzeilig. Wenn Sie also dem Weirich-Stil folgen, sehen Sie fast genauso aus wie dem Rails-Stil.

Ich habe jahrelang den Weirich-Stil verwendet, mich aber davon entfernt, um immer Zahnspangen zu verwenden . Ich erinnere mich nicht, jemals die Informationen aus dem Blockstil verwendet zu haben, und die Definition ist irgendwie vage. Beispielsweise:

date = Timecop.freeze(1.year.ago) { format_date(Time.now) }
customer = Timecop.freeze(1.year.ago) { create(:customer) }

Sind diese prokudual oder funktional?

Und die Sache mit der Zeilenanzahl ist meiner Meinung nach einfach nutzlos. Ich weiß, ob es 1 oder mehr Zeilen gibt und warum genau sollte ich den Stil ändern, nur weil ich Zeilen hinzugefügt oder entfernt habe?