Hier ist ein anderer Weg, dies zu verstehen.
Ein Block ist ein Codeabschnitt, der an den Aufruf eines Aufrufs einer Methode für ein Objekt angehängt ist. Im folgenden Beispiel ist self eine Instanz einer anonymen Klasse, die von ActionView :: Base im Rails-Framework (das selbst viele Hilfsmodule enthält) erbt. Karte ist eine Methode, die wir selbst aufrufen. Wir übergeben der Methode ein Argument und hängen den Block immer an das Ende des Methodenaufrufs an:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, wir übergeben einen Codeabschnitt an eine Methode. Aber wie nutzen wir diesen Block? Eine Möglichkeit besteht darin, den Codeabschnitt in ein Objekt umzuwandeln. Ruby bietet drei Möglichkeiten, um einen Codeabschnitt in ein Objekt umzuwandeln
# lambda
> l = lambda { |a| a + 1 }
> l.call(1)
=> 2
# Proc.new
> l2= Proc.new { |a| a + 1 }
> l2.call(1)
=> 2
# & as the last method argument with a local variable name
def add(&block)
end
In der obigen Methode konvertiert & den an die Methode übergebenen Block in ein Objekt und speichert dieses Objekt im lokalen Variablenblock. In der Tat können wir zeigen, dass es das gleiche Verhalten wie Lambda und Proc.new hat:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Das ist wichtig. Wenn Sie einen Block an eine Methode übergeben und mit & konvertieren, verwendet das erstellte Objekt Proc.new, um die Konvertierung durchzuführen.
Beachten Sie, dass ich die Verwendung von "proc" als Option vermieden habe. Das liegt daran, dass es Ruby 1.8 ist, dasselbe wie Lambda und in Ruby 1.9 dasselbe wie Proc.new und in allen Ruby-Versionen sollte es vermieden werden.
Dann fragen Sie sich, was der Unterschied zwischen Lambda und Proc.new ist.
Erstens verhält sich Lambda in Bezug auf die Parameterübergabe wie ein Methodenaufruf. Es wird eine Ausnahme ausgelöst, wenn Sie die falsche Anzahl von Argumenten übergeben. Im Gegensatz dazu verhält sich Proc.new wie eine parallele Zuweisung. Alle nicht verwendeten Argumente werden in nil konvertiert:
> l = lambda {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb47e40@(irb):19 (lambda)>
> l.call(1)
ArgumentError: wrong number of arguments (1 for 2)
> l2 = Proc.new {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb261a0@(irb):21>
> l2.call(1)
1 +
Zweitens behandeln Lambda und Proc.new das Schlüsselwort return unterschiedlich. Wenn Sie innerhalb von Proc.new eine Rückgabe durchführen, wird diese tatsächlich von der einschließenden Methode, dh dem umgebenden Kontext, zurückgegeben. Wenn Sie von einem Lambda-Block zurückkehren, kehrt er nur vom Block zurück, nicht von der einschließenden Methode. Grundsätzlich verlässt es den Aufruf des Blocks und setzt die Ausführung mit dem Rest der einschließenden Methode fort.
> def add(a,b)
l = Proc.new { return a + b}
l.call
puts "now exiting method"
end
> add(1,1)
=> 2 # NOTICE it never prints the message "now exiting method"
> def add(a,b)
l = lambda { return a + b }
l.call
puts "now exiting method"
end
> add(1,1)
=> now exiting method # NOTICE this time it prints the message "now exiting method"
Warum also dieser Verhaltensunterschied? Der Grund dafür ist, dass wir mit Proc.new Iteratoren im Kontext einschließender Methoden verwenden und logische Schlussfolgerungen ziehen können. Schauen Sie sich dieses Beispiel an:
> def print(max)
[1,2,3,4,5].each do |val|
puts val
return if val > max
end
end
> print(3)
1
2
3
4
Wir erwarten, dass beim Aufrufen von return innerhalb des Iterators diese von der einschließenden Methode zurückgegeben wird. Denken Sie daran, dass die an Iteratoren übergebenen Blöcke mit Proc.new in Objekte konvertiert werden. Wenn Sie also return verwenden, wird die einschließende Methode beendet.
Sie können sich Lambdas als anonyme Methoden vorstellen. Sie isolieren einzelne Codeblöcke in ein Objekt, das wie eine Methode behandelt werden kann. Stellen Sie sich ein Lambda letztendlich als anomische Methode und Proc.new als Inline-Code vor.
returnAussage inprocversus zurückkehrtlambda.