Dies sind drei Wege, wie Ruby Codestücke als Daten verarbeitet. Ein Block wird an eine Methode übergeben (ist kein Objekt); ein Proc und ein Lambda sind Objekte, die einen Block einpacken (aufrufbar, speicherbar). Procs und Lambdas unterscheiden sich subtil in der Argumentprüfung und dem return-Verhalten.
[1, 2, 3].each { |n| puts n } # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
Ein Block ist der Code, der an eine Methode übergeben wird (in { } oder do...end) — es ist kein eigenständiges Objekt, das man speichern kann; er ist an den Methodenaufruf gebunden.
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5) # 25
square.(5) # 25 (alternate call syntax)
# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 } # the -> "stabby lambda" syntax
double.call(5) # 10
Procs und Lambdas verpacken einen Block in ein Objekt, das man Variablen zuweisen, weitergeben und später aufrufen kann (.call) — nützlich zum Speichern von wiederverwendbarem Verhalten.
1. ARGUMENT CHECKING:
lambda → STRICT: errors if wrong number of arguments (like a method)
proc → LENIENT: ignores extra args, fills missing with nil
2. RETURN behavior:
lambda → `return` returns from the LAMBDA (like a normal method)
proc → `return` returns from the ENCLOSING METHOD (can surprise you!)
def test_proc
p = Proc.new { return 10 }
p.call # returns from test_proc ENTIRELY → 10
return 20 # never reached!
end
def test_lambda
l = lambda { return 10 }
l.call # returns from the LAMBDA only → 10
return 20 # reached → test_lambda returns 20
end
Der wichtigste Unterschied: ein Lambda verhält sich wie eine Methode (strikte Argumente, return beendet nur das Lambda), während ein Proc toleranter ist (ignoriert Argumentabweichungen, und return beendet die umgebende Methode — was zu überraschendem Verhalten führen kann). Lambdas werden generell bevorzugt für ihr methodenähnliches, vorhersehbares Verhalten.
Das Verständnis von Blocks, Procs und Lambdas — und besonders ihrer Unterschiede — ist wichtiges Ruby-Wissen, das ein tieferes Verständnis dafür widerspiegelt, wie Ruby Code als Daten verarbeitet. Blocks sind am häufigsten (an Methoden für Iteration und Callbacks übergeben — Rubys charakteristisches Merkmal), während Procs und Lambdas Blocks in speicherbare, wiederverwendbare Objekte verwandeln, die man Variablen zuweisen, weitergeben und später aufrufen kann (nützlich zum Speichern von Verhalten, zum Erstellen funktionaler Muster und zum Übergeben von Callbacks als Werte).
Die Hauptunterschiede zwischen Procs und Lambdas sind subtil, aber wichtig und ein häufiges Interviewthema: Argumentprüfung (Lambdas sind streng wie Methoden, Procs sind tolerant) und besonders return-Verhalten (das return eines Lambdas beendet nur das Lambda, während das return eines Procs die umgebende Methode beendet — was zu überraschendem, schwer zu debuggendem Verhalten führen kann).
Das Verständnis dieser Unterscheidungen — dass ein Lambda wie eine Methode funktioniert (streng, vorhersehbar, mit lokalem return), während ein Proc toleranter mit überraschenden return-Semantiken ist — ist wichtig für ihre korrekte Verwendung und für die häufige Empfehlung, Lambdas zu bevorzugen für ihr vorhersehbares, methodenähnliches Verhalten.
Während Blocks alltägliches Ruby sind und Procs/Lambdas für speicherbare Callbacks und funktionale Muster verwendet werden, zeigt das Verständnis aller drei (besonders die Proc-vs-Lambda-return- und Argumentunterschiede) solides Ruby-Wissen, hilft dir, die Proc-return-Falle zu vermeiden, und ist ein klassisches Interviewthema, das Entwickler unterscheidet, die Rubys Umgang mit Code als Objekten wirklich verstehen.