斯卡拉 |闭包

Scala 闭包是使用一个或多个自由变量的函数，该函数的返回值取决于这些变量。自由变量在闭包函数之外定义，不作为该函数的参数包含在内。所以闭包函数和普通函数的区别在于自由变量。自由变量是未在函数内定义且未作为函数参数传递的任何类型的变量。自由变量未绑定到具有有效值的函数。该函数不包含自由变量的任何值。
例子：
如果我们定义如下所示的函数：

def example(a:double) = a*p / 100

现在在运行上面的代码时，我们会得到一个错误 start not found p。所以现在我们在函数之外给p一个值。

// defined the value of p as 10
val p = 10
  
// define this closure.
def example(a:double) = a*p / 100

现在上述函数已准备好运行，因为自由变量有一个值。现在，如果我们将函数运行为：

Calling the function: example(10000)
Input: p = 10
Output: double = 1000.0

现在如果自由变量的值发生变化，闭包函数的值又会如何变化呢？
所以基本上闭包函数所做的是，它获取自由变量的最新状态并相应地更改闭包函数的值。

Input: p = 10
Output: double = 1000.0

Input: p = 20
Output: double = 2000.0

根据自由变量的类型，闭包函数可以进一步分为纯函数和非纯函数。如果我们给自由变量一个var类型，那么该变量往往会在整个代码中随时更改值，从而可能导致更改闭包函数的值。因此这个闭包是一个不纯的函数。另一方面，如果我们声明类型为val的自由变量，那么变量的值将保持不变，从而使闭包函数成为纯函数。

例子：

// Addition of two numbers with 
// Scala closure
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        println( "Final_Sum(1) value = " + sum(1))
        println( "Final_Sum(2) value = " + sum(2))
        println( "Final_Sum(3) value = " + sum(3))
    }
          
    var a = 4
      
    // define closure function
    val sum = (b:Int) => b + a
}

输出：

Final_Sum(1) value = 5
Final_Sum(2) value = 6
Final_Sum(3) value = 7

这里，在上面的程序函数中sum是一个闭包函数。 var a = 4 是不纯的闭包。 a的值相同，b的值不同。
例子：

// Scala closure program to print a string
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
      
        var employee = 50
      
        // define closure function
        val gfg = (name: String) => println(s"Company name is $name"+
                       s" and total no. of employees are $employee")
          
        gfg("geeksforgeeks")
    }
}

输出：

Company name is geeksforgeeks and total no. of employees are 50.

在这里，在上面的例子中 gfg是一个闭包。 var employee 是可以更改的可变变量。