Ce sont trois façons dont Ruby gère des chunks de code en tant que données. Un block est passé à une méthode (ce n'est pas un objet) ; un Proc et une lambda sont des objets qui enveloppent un block (callable, storable). Les Procs et les lambdas diffèrent subtilement en termes de vérification d'arguments et de comportement de return.
[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
Un block est le code passé à une méthode (entre { } ou do...end) — ce n'est pas un objet standalone que vous pouvez stocker ; il est lié à l'appel de méthode.
# 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
Les Procs et les lambdas enveloppent un block dans un objet que vous pouvez assigner à des variables, passer partout et appeler plus tard (.call) — utile pour stocker du comportement réutilisable.
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
La différence la plus importante : une lambda se comporte comme une méthode (arguments stricts, return sort seulement de la lambda), tandis qu'un proc est plus tolérant (ignore les décalages d'arguments, et return sort de la méthode englobante — ce qui peut causer un comportement surprenant). Les lambdas sont généralement préférées pour leur comportement prévisible, similaire aux méthodes.
Comprendre les blocks, les procs et les lambdas — et surtout leurs différences — est une connaissance Ruby importante qui reflète une compréhension plus profonde de la façon dont Ruby gère le code en tant que données. Les Blocks sont les plus courants (passés aux méthodes pour l'itération et les callbacks — la signature caractéristique de Ruby), tandis que les procs et les lambdas transforment les blocks en objets stockables, réutilisables que vous pouvez assigner à des variables, passer partout et appeler plus tard (utile pour stocker du comportement, construire des patterns fonctionnels et passer des callbacks en tant que valeurs).
Les différences clés entre les procs et les lambdas sont subtiles mais importantes et un sujet d'interview fréquent : la vérification d'arguments (les lambdas sont strictes comme les méthodes, les procs sont tolérants) et surtout le comportement de return (le return d'une lambda sort seulement de la lambda, tandis que le return d'un proc sort de la méthode englobante — ce qui peut causer un comportement surprenant et difficile à déboguer).
Comprendre ces distinctions — qu'une lambda se comporte comme une méthode (stricte, prévisible, avec un return localisé) tandis qu'un proc est plus tolérant avec une sémantique de return surprenante — est important pour les utiliser correctement et pour la recommandation courante de préférer les lambdas pour leur comportement prévisible, similaire aux méthodes.
Tandis que les blocks sont du Ruby quotidien et que les procs/lambdas sont utilisés pour les callbacks stockables et les patterns fonctionnels, comprendre tous les trois (surtout les différences de return et d'arguments entre proc et lambda) reflète une connaissance solide de Ruby, vous aide à éviter le gotcha du proc-return et est un sujet d'interview classique qui distingue les développeurs qui comprennent vraiment comment Ruby gère le code en tant qu'objets.