Đây là một cách khác để hiểu điều này.
Một khối là một đoạn mã được gắn vào lời gọi đến một cuộc gọi của một phương thức trên một đối tượng. Trong ví dụ dưới đây, self là một thể hiện của một lớp ẩn danh kế thừa từ ActionView :: Base trong khung Rails (bản thân nó bao gồm nhiều mô đun trợ giúp). Thẻ là một phương pháp chúng tôi tự gọi. Chúng ta truyền một đối số cho phương thức và sau đó chúng ta luôn gắn khối vào cuối lời gọi phương thức:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, vì vậy chúng tôi đang chuyển một đoạn mã cho một phương thức. Nhưng làm thế nào để chúng ta sử dụng khối này? Một tùy chọn là chuyển đổi đoạn mã thành một đối tượng. Ruby cung cấp ba cách để chuyển đổi một đoạn mã thành một đối tượng
# 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
Trong phương thức trên, & chuyển đổi khối được truyền cho phương thức thành một đối tượng và lưu trữ đối tượng đó trong khối biến cục bộ. Trên thực tế, chúng ta có thể chỉ ra rằng nó có hành vi tương tự như lambda và Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Điều này quan trọng. Khi bạn truyền một khối cho một phương thức và chuyển đổi nó bằng cách sử dụng &, đối tượng mà nó tạo ra sử dụng Proc.new để thực hiện chuyển đổi.
Lưu ý rằng tôi đã tránh sử dụng "Proc" làm tùy chọn. Đó là bởi vì Ruby 1.8, nó giống như lambda và trong Ruby 1.9, nó giống với Proc.new và trong tất cả các phiên bản Ruby nên tránh.
Vì vậy, sau đó bạn hỏi sự khác biệt giữa lambda và Proc.new là gì?
Đầu tiên, về mặt truyền tham số, lambda hoạt động giống như một cuộc gọi phương thức. Nó sẽ đưa ra một ngoại lệ nếu bạn vượt qua số lượng đối số sai. Ngược lại, Proc.new hành xử giống như sự phân công song song. Tất cả các đối số không sử dụng được chuyển đổi thành nil:
> 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 +
Thứ hai, lambda và Proc.new xử lý từ khóa return khác nhau. Khi bạn thực hiện trả lại bên trong Proc.new, nó thực sự trở về từ phương thức kèm theo, đó là bối cảnh xung quanh. Khi bạn trở về từ khối lambda, nó chỉ trả về từ khối chứ không phải phương thức kèm theo. Về cơ bản, nó thoát khỏi lệnh gọi đến khối và tiếp tục thực hiện với phần còn lại của phương thức kèm theo.
> 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"
Vậy tại sao sự khác biệt hành vi này? Lý do là bởi với Proc.new, chúng ta có thể sử dụng các trình vòng lặp bên trong bối cảnh của các phương thức kèm theo và rút ra kết luận logic. Nhìn vào ví dụ này:
> 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
Chúng tôi hy vọng rằng khi chúng tôi gọi trở lại bên trong iterator, nó sẽ trở lại từ phương thức kèm theo. Hãy nhớ rằng các khối được truyền cho các trình vòng lặp được chuyển đổi thành các đối tượng bằng Proc.new và đó là lý do tại sao khi chúng ta sử dụng return, nó sẽ thoát khỏi phương thức kèm theo.
Bạn có thể nghĩ lambdas như các phương thức ẩn danh, chúng cô lập các khối mã riêng lẻ thành một đối tượng có thể được xử lý như một phương thức. Cuối cùng, hãy nghĩ về một lambda hành xử như một phương pháp vô cảm và Proc.new hành xử như mã nội tuyến.
returncâu lệnh trả về từprocso vớilambda.