Ini adalah tiga cara Ruby mengendalikan kepingan kod sebagai data. Blok dihantar kepada kaedah (bukan objek); Proc dan lambda adalah objek yang membungkus blok (boleh dipanggil, boleh disimpan). Proc dan lambda berbeza secara halus dalam pemeriksaan argumen dan tingkah laku 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
Blok adalah kod yang dihantar kepada kaedah (dalam { } atau do...end) — ia bukan objek bersendirian yang boleh anda simpan; ia terikat pada panggilan kaedah.
# 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
Proc dan lambda membungkus blok menjadi objek yang boleh anda tetapkan kepada pemboleh ubah, hantar sekitar, dan panggil kemudian (.call) — berguna untuk menyimpan tingkah laku yang boleh digunakan semula.
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
Perbezaan yang paling penting: lambda berkelakuan seperti kaedah (argumen ketat, return keluar hanya dari lambda), manakala proc lebih bertolak ansur (mengabaikan ketidakpadanan argumen, dan return keluar dari kaedah yang mengelilinginya — yang boleh menyebabkan tingkah laku yang mengejutkan). Lambda secara amnya lebih diutamakan kerana tingkah lakunya yang seperti kaedah dan boleh dijangka.
Memahami blok, proc, dan lambda — dan terutamanya perbezaannya — adalah pengetahuan Ruby yang penting yang mencerminkan pemahaman lebih mendalam tentang cara Ruby mengendalikan kod sebagai data. Blok adalah yang paling biasa (dihantar kepada kaedah untuk lelaran dan callback — ciri tanda tangan Ruby), manakala proc dan lambda menukar blok menjadi objek yang boleh disimpan dan digunakan semula yang boleh anda tetapkan kepada pemboleh ubah, hantar sekitar, dan panggil kemudian (berguna untuk menyimpan tingkah laku, membina corak berfungsi, dan menghantar callback sebagai nilai).
Perbezaan utama antara proc dan lambda adalah halus tetapi penting dan merupakan topik temu duga yang kerap: pemeriksaan argumen (lambda ketat seperti kaedah, proc bertolak ansur) dan terutamanya tingkah laku return (return lambda keluar hanya dari lambda, manakala return proc keluar dari kaedah yang mengelilinginya — yang boleh menyebabkan tingkah laku yang mengejutkan dan sukar untuk dinyahpepijat).
Memahami perbezaan ini — bahawa lambda berkelakuan seperti kaedah (ketat, boleh dijangka, dengan return setempat) manakala proc lebih bertolak ansur dengan semantik return yang mengejutkan — adalah penting untuk menggunakannya dengan betul dan untuk cadangan biasa untuk mengutamakan lambda kerana tingkah lakunya yang boleh dijangka dan seperti kaedah.
Walaupun blok adalah Ruby harian dan proc/lambda digunakan untuk callback yang boleh disimpan dan corak berfungsi, memahami ketiga-tiganya (terutamanya perbezaan return dan argumen proc-lawan-lambda) mencerminkan pengetahuan Ruby yang kukuh, membantu anda mengelakkan perangkap return proc, dan merupakan topik temu duga klasik yang membezakan pembangun yang benar-benar memahami pengendalian kod sebagai objek oleh Ruby.