Ruby 中的闭包

在 Ruby 中，闭包是一个函数或代码块，其中的变量绑定到调用闭包的环境。或者换句话说，闭包可以被视为可以分配给另一个变量或可以作为参数传递给任何函数的变量。

闭包块可以在一个范围内定义，并且可以在不同的范围内调用。
闭包在创建时始终记住其范围内的变量，并且当它被调用时，即使它们不在当前范围内，它也可以访问该变量，即闭包在定义时保留其对词法环境的了解。
在 Ruby 中， Blocks ， procs ， lambdas是clousers。

块

块是 Ruby 闭包的最简单形式。它不是一个对象，而是一段代码，包含在大括号{}或do...end之间。

您可以根据代码块的编写方式将一个或多个变量传递到您的块中。
您可以使用 yield 语句在具有值的方法中调用块。
它没有自己的名字。

Syntax:

Using {}

Using do…end

编程需要懂一点英语

示例 1：

block_name { #statements_to_be_executed }

输出：

block_name do 

   #statement-1  
   #statement-2  
   .
   .
end

示例 2：

# Ruby program to illustrate blocks
arr = [10, 11, 13, 41, 59]
  
arr.each do | item |
puts item
end

输出：

说明：在上面的例子中，方法名是 print_once。首先，调用方法语句，它将显示“Hello！我是方法。但是一旦 yield 语句执行，控制就进入块，块将执行它的语句并打印“你好！我是方法”。一旦块执行，它就会将控制权交还给方法，并且方法将从调用 yield 语句的位置继续执行。您还可以在单个方法中使用多个 yield 语句，如 print_twice 方法所示。

过程

现在第二种类型的 ruby 闭包是Procs ，它与 block 非常相似，但有一些区别，比如procs被分配或存储在变量中，并通过调用 .call 方法执行。您可以将一个或多个 proc 传递给一个方法。我们知道 block 不是一个对象，但 Proc 是一个对象。它是一个变成 Proc 类的对象的块，这就是为什么 Proc 看起来类似于类的实例化的原因。
句法：

# Ruby program to illustrate blocks
  
# Method with single yield statement
def print_once
      
    # statement of method
    puts"Hello! I am Method"
      
  # using yield statement
  yield
end
  
# Block 1
print_once { puts "Hello! I am Block 1" }
  
# Method with two yield statement 
def print_twice
      
  # using yield statement
  yield
  yield
end
  
# Block 2
print_twice { puts "Hello! I am Block 2" }

示例 1：

Hello! I am Method
Hello! I am Block 1
Hello! I am Block 2
Hello! I am Block 2

输出：

variableName = Proc.new {# Statement}

# Executing Procs
variableName.call

解释：在上面的例子中，我们将一个块分配给Proc类的一个实例，并将它分配给变量，即example，并在其上调用方法.call。
示例 2：

# Ruby program to illustrate Procs
  
# Creating proc
example = Proc.new{"GeeksforGeeks"}
  
# Executing proc
# Using .call method
puts example.call

输出：

GeeksforGeeks

说明：在本例中，我们使用 .call 方法在 Proc 中传递参数。 Procs 更慷慨地接受参数。它用nil填充缺失的参数，如果 proc 有多个参数，则解构单个数组参数。它不会给出额外参数的错误。

拉姆达

我们可以说lambda和Procs有点相同，没有太大区别。此外，我们可以说 lambda 是一种使用特殊语法定义块及其参数的方法。 Lambda 就像一个常规方法，因为它们在调用时强加了传递的参数数量，并且它们像普通方法一样返回（它像对待方法一样对待 return 关键字）。如果你将一个参数传递给一个不期望它的 lambda，那么你将得到一个 ArgumentError。
句法：

# Ruby program to illustrate Procs
  
# Creating proc
a = Proc.new {|x, y| "x = #{x}, y = #{y}" }
  
# Executing proc
puts a.call(1, 2)      
puts a.call([2, 1])    
puts a.call(3, 4, 8)   
puts a.call(9)

示例 1：

x = 1, y = 2
x = 2, y = 1
x = 3, y = 4
x = 9, y =

输出：

variableName = -> {# Statement}

示例 2：

# Ruby program to illustrate lambda
  
# Creating lambda
times_one = ->(x){ x * 2 }
  
# Displaying result
puts times_one.call(10)
  
# Creating lambda
times_two = lambda{"GeeksforGeeks"}
  
# Displaying result
puts times_two.call

输出：

20
GeeksforGeeks