InhaltsverzeichnisKlicke auf den Link, um zur gewünschten Stelle zu navigieren
Dieser Inhalt wurde automatisch aus dem Ukrainischen übersetzt.
In Ruby ist Proc ein Objekt, das einen Codeblock speichert und es ermöglicht, ihn später auszuführen. Es ist wie ein "gespeicherter Block" oder eine "Funktion in einer Box".
Beispiel 1: Erstellen eines Proc
say_hello = Proc.new { puts "Hallo!" }
say_hello.call
# => "Hallo!"
Wir haben ein Proc-Objekt erstellt, das den Code { puts "Hallo!" } speichert. Dann haben wir es über .call aufgerufen.
Beispiel 2: Übergabe von Proc an eine Methode
def run_twice(proc)
proc.call
proc.call
end
run_twice(Proc.new { puts "Hi!" })
# => "Hi!"
# => "Hi!"
Wir haben einen Codeblock als Objekt übergeben und ihn mehrmals aufgerufen. Das ist sehr praktisch, wenn man Logik wiederverwenden möchte.
Proc - warum dieser Name?
Es ist einfacher, sich die Namen von Methoden zu merken, wenn man weiß, was sie bedeuten. Der Name Proc in Ruby ist eine Abkürzung für "Procedure" (Prozedur). In Programmiersprachen, seit den Zeiten von Lisp und Scheme, bedeutete der Begriff procedure "ein Stück Code, das später ausgeführt werden kann" - also eine Funktion, die als Argument übergeben oder aufgerufen werden kann.
Als Yukihiro Matsumoto (Matz), der Schöpfer von Ruby, die Sprache entwarf, wollte er, dass Ruby einen einfachen und flexiblen Weg hat, mit Codeblöcken zu arbeiten. Er nahm die Idee von Prozeduren aus Lisp/Scheme und machte sie zu Objekten - so entstand die Klasse Proc (procedure object).
Was ist eine Lambda?
Lambda ist auch ein Proc, aber mit einigen Unterschieden. Sie kann auf verschiedene Arten erstellt werden:
-> { }
say_hi = -> { puts "Hi!" }
say_hi.call
# => "Hi!"
und lambda {}
say_hello = lambda { puts "Hallo!" }
Um zu beweisen, dass eine Lambda ein Proc ist:
say_hi.class => Proc
Der Hauptunterschied zwischen Proc und Lambda
1. Lambda überprüft die Anzahl der Argumente, Proc hingegen nicht.
p1 = Proc.new { |a, b| puts a, b }
l1 = ->(a, b) { puts a, b }
p1.call(1)
# => 1
# => nil (das zweite Argument ist einfach nil)
l1.call(1)
# => ArgumentError: falsche Anzahl von Argumenten
2. return in Proc verlässt die gesamte Methode, nicht nur den Proc. In Lambda beendet return nur die Lambda selbst.
Und betrachten wir Beispiele
def test_proc
p = Proc.new { return "Von Proc" }
p.call
"Nach Proc" # diese Zeile wird nicht ausgeführt
end
puts test_proc
# => "Von Proc"
Wenn Proc return aufruft, verlässt es sofort die Methode, in der der Proc erstellt wurde, und nicht nur den Block.
return in Lambda beendet nur die Lambda selbst
def test_lambda
l = -> { return "Von Lambda" }
result = l.call
"Nach Lambda: #{result}" # diese Zeile wird ausgeführt
end
puts test_lambda
# => "Nach Lambda: Von Lambda"
Eine Lambda verhält sich wie eine normale Methode: return beendet nur die Lambda selbst, und die Methode setzt die Ausführung fort.
& und to_proc
Wenn Sie in Ruby ein Objekt mit einem Ampersand & übergeben, versucht Ruby, .to_proc darauf aufzurufen und verwendet den erhaltenen Proc als Block.
def run(&block)
block.call
end
run { puts "Funktioniert!" }
# => "Funktioniert!"
Hier hat Ruby automatisch .to_proc für unseren Block { ... } aufgerufen und ihn der Variablen block übergeben.
Dieser Beitrag hat noch keine Ergänzungen vom Autor.
![Was passiert, wenn man [1, 2, 3].map(&Person) aufruft?](https://d3kb0xa9zqcv9v.cloudfront.net/yspsysxd89do2yacx55htq7fw0ha)
