Berikut ini cara lain untuk memahami hal ini.
Blok adalah bongkahan kode yang dilampirkan pada pemanggilan panggilan metode pada suatu objek. Dalam contoh di bawah ini, self adalah turunan dari kelas anonim yang mewarisi dari ActionView :: Base dalam kerangka Rails (yang itu sendiri mencakup banyak modul pembantu). kartu adalah metode yang kita sebut sendiri. Kami menyampaikan argumen ke metode dan kemudian kami selalu melampirkan blok ke akhir doa metode:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Oke, jadi kami mengirimkan sepotong kode ke sebuah metode. Tetapi bagaimana kita memanfaatkan blok ini? Salah satu opsi adalah mengubah potongan kode menjadi objek. Ruby menawarkan tiga cara untuk mengubah sepotong kode menjadi objek
# lambda
> l = lambda { |a| a + 1 }
> l.call(1)
=> 2
# Proc.new
> l2= Proc.new { |a| a + 1 }
> l2.call(1)
=> 2
# & as the last method argument with a local variable name
def add(&block)
end
Dalam metode di atas, & mengubah blok yang diteruskan ke metode menjadi objek dan menyimpan objek itu di blok variabel lokal. Bahkan, kami dapat menunjukkan bahwa ia memiliki perilaku yang sama dengan lambda dan Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Ini penting. Saat Anda meneruskan blok ke metode dan mengonversinya menggunakan &, objek yang dibuatnya menggunakan Proc.new untuk melakukan konversi.
Perhatikan bahwa saya menghindari penggunaan "proc" sebagai opsi. Itu karena Ruby 1.8, sama dengan lambda dan di Ruby 1.9, itu sama dengan Proc.new dan di semua versi Ruby itu harus dihindari.
Jadi, Anda bertanya apa perbedaan antara lambda dan Proc.new?
Pertama, dalam hal melewati parameter, lambda berperilaku seperti pemanggilan metode. Ini akan memunculkan pengecualian jika Anda melewatkan jumlah argumen yang salah. Sebaliknya, Proc.new berperilaku seperti penugasan paralel. Semua argumen yang tidak digunakan dikonversi menjadi nihil:
> l = lambda {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb47e40@(irb):19 (lambda)>
> l.call(1)
ArgumentError: wrong number of arguments (1 for 2)
> l2 = Proc.new {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb261a0@(irb):21>
> l2.call(1)
1 +
Kedua, lambda dan Proc.new menangani kata kunci kembali secara berbeda. Ketika Anda melakukan pengembalian di dalam Proc.new, itu sebenarnya kembali dari metode melampirkan, yaitu konteks sekitarnya. Ketika Anda kembali dari blok lambda, itu hanya kembali dari blok, bukan metode melampirkan. Pada dasarnya, ia keluar dari panggilan ke blok dan melanjutkan eksekusi dengan sisa metode terlampir.
> def add(a,b)
l = Proc.new { return a + b}
l.call
puts "now exiting method"
end
> add(1,1)
=> 2 # NOTICE it never prints the message "now exiting method"
> def add(a,b)
l = lambda { return a + b }
l.call
puts "now exiting method"
end
> add(1,1)
=> now exiting method # NOTICE this time it prints the message "now exiting method"
Lantas mengapa perbedaan perilaku ini? Alasannya adalah karena dengan Proc.new baru, kita dapat menggunakan iterator dalam konteks melampirkan metode dan menarik kesimpulan logis. Lihatlah contoh ini:
> def print(max)
[1,2,3,4,5].each do |val|
puts val
return if val > max
end
end
> print(3)
1
2
3
4
Kami berharap bahwa ketika kami meminta return di dalam iterator, itu akan kembali dari metode terlampir. Ingat blok yang dilewatkan ke iterator dapat dikonversi ke objek menggunakan Proc.new dan itulah sebabnya ketika kita menggunakan return, itu akan keluar dari metode melampirkan.
Anda dapat menganggap lambdas sebagai metode anonim, mereka mengisolasi blok kode individu menjadi objek yang dapat diperlakukan seperti metode. Pada akhirnya, pikirkan lambda sebagai berperilaku sebagai metode anomi dan Proc.new baru berperilaku sebagai kode inline.
returnpernyataan kembaliprocdibandingkan denganlambda.