Bunlar Ruby'nin kod parçalarını veri olarak işlemesinin üç yoludur. Bir block bir metoda iletilir (bir nesne değildir); Proc ve lambda bir bloğu sarmalayan nesnelerdir (çağrılabilir, depolanabilir). Proclar ve lambdalar bağımsız değişken kontrolü ve return davranışında incelik farkları gösterir.
[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
Bir block, bir metoda iletilen koddur ({ } veya do...end içinde) — bu, depolayabileceğiniz bağımsız bir nesne değildir; metot çağrısına bağlıdır.
# 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 ve lambdas bir bloğu nesneye dönüştürür; değişkenlere atayabilir, etrafında taşıyabilir ve daha sonra çağırabilirsiniz (.call) — yeniden kullanılabilir davranışları depolamak için kullanışlıdır.
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
En önemli fark: bir lambda bir metod gibi davranır (katı bağımsız değişkenler, return sadece lambdadan çıkar), bir proc ise daha toleranttır (bağımsız değişken uyumsuzluklarını görmezden gelir ve return kapsayan metottan çıkar — bu şaşırtıcı davranışlara neden olabilir). Lambdalar genellikle tercih edilir çünkü davranışları metod benzeri ve tahmin edilebilirdir.
Blocks, procs ve lambdaları anlamak — ve özellikle aralarındaki farkları — Ruby'nin kodu veri olarak nasıl işlediğinin daha derin bir anlayışını yansıtan önemli Ruby bilgisidir. Blocks en yaygın olanıdır (iterasyon ve geri çağrılar için metotlara iletilir — Ruby'nin imza özelliği), procs ve lambdalar ise bloğu depolanabilir, yeniden kullanılabilir nesnelere dönüştürür; değişkenlere atayabilir, etrafında taşıyabilir ve daha sonra çağırabilirsiniz (davranışı depolamak, işlevsel desenler oluşturmak ve geri çağrıları değerler olarak iletmek için kullanışlıdır).
Proclar ve lambdalar arasındaki anahtar farklar incelik gösterir ancak önemlidir ve sık sorulan bir mülakat konusudur: bağımsız değişken kontrolü (lambdalar metotlar gibi katıdır, proclar toleranttır) ve özellikle return davranışı (bir lambdanın returnu sadece lambdadan çıkar, procun returnu ise kapsayan metottan çıkar — bu şaşırtıcı, hata ayıklanması zor davranışlara neden olabilir).
Bu ayrımları anlamak — lambda'nın bir metod gibi davranması (katı, tahmin edilebilir, yerelleştirilmiş return) procun ise daha tolerant ve şaşırtıcı return semantiğine sahip olması — onları doğru şekilde kullanmak ve lambdaları tercih etme önerisinin yaygın olması için önemlidir; çünkü lambdalar tahmin edilebilir, metod benzeri davranış gösterir.
Blocklar günlük Ruby'dir ve proclar/lambdalar depolanabilir geri çağrılar ve işlevsel desenler için kullanılırken, her üçünü (özellikle proc-vs-lambda return ve bağımsız değişken farklarını) anlamak sağlam Ruby bilgisini yansıtır, proc-return tuzağını önlemenize yardımcı olur ve Ruby'nin kodu nesneler olarak işlemesini gerçekten anlayan geliştiricileri ayıran klasik bir mülakat konusudur.