Scala:函数和闭包

叁歲伎倆 2022-07-15 13:10 213阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/52902271][blog.csdn.net_pipisorry_article_details_52902271]

# Scala函数    #

Scala 有函数和方法，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

我们可以在任何地方定义函数，甚至可以在函数内定义函数（内嵌函数）。更重要的一点是 Scala 函数名可以由以下特殊字符：**+, ++, ~, &,-, -- , \\, /, :** 等。

## 函数声明和定义    ##

Scala 函数声明格式如下：

def functionName ([参数列表]) : [return type]

如果你不写等于号和方法主体，那么方法会被隐式声明为"抽象(abstract)"，包含它的类型于是也是一个抽象类型。

方法定义由一个def 关键字开始，紧接着是可选的参数列表，一个冒号"：" 和方法的返回类型，一个等于号"="，最后是方法的主体。

Scala 函数定义格式如下：

def functionName ([参数列表]) : [return type] = {
       
       function body
       return [expr]
    }

以上代码中 **return type** 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔。

## 函数返回值 ##

在scala中，语句块的最后一个值就是这个语句块的值，因此函数并不使用return来返回值，而是简单的把结果放到最后一条语句。

如def getK: Int = k

## 函数调用 ##

Scala 提供了多种不同的函数调用方式：

以下是调用方法的标准格式：

functionName( 参数列表 )

如果函数使用了实例的对象来调用，我们可以使用类似java的格式 (使用 **.** 号)：

[instance.]functionName( 参数列表 )

## Scala通用函数 ##

map  
map接受一个处理单个元素的函数，map把这个函数运用在列表的每个元素上放回一个一样长的列表  
filter  
filter接受一个返回boolean的的值，filter会取出得到true的元素，返回过滤过的列表  
foreach  
类似于map  
mkString  
相当于toString，但是需要一个分隔符  
zip  
zip把两个列表的元素依次结合得到一个元祖集合  
reduce  
reduceLeft接受一个接受两个参数的函数，reduceLeft会依次把前一次得到的结果和下一个列表元素传递给函数，最后得到一个单个元素  
fold  
foldLeft和foldRight接受一个需要两个参数的函数，并且依层调用如(1::2::3).foldLeft(1)(\_\*\_)=6  
以层次话的方式求值

## 函数概念解析接案例 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/functions-call-by-name.html" rel="nofollow">函数传名调用(Call-by-Name)</a></td> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/functions-named-arguments.html" rel="nofollow">指定函数参数名</a></td> 
  </tr> 
  <tr> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/functions-variable-arguments.html" rel="nofollow">函数 - 可变参数</a></td> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/recursion-functions.html" rel="nofollow">递归函数</a></td> 
  </tr> 
  <tr> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/functions-default-parameter-values.html" rel="nofollow">默认参数值</a></td> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/higher-order-functions.html" rel="nofollow">高阶函数</a></td> 
  </tr> 
  <tr> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/nested-functions.html" rel="nofollow">内嵌函数</a></td> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/anonymous-functions.html" rel="nofollow">匿名函数</a></td> 
  </tr> 
  <tr> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/partially-applied-functions.html" rel="nofollow">偏应用函数</a></td> 
   <td style="width:50%"><a href="http://www.runoob.com/scala/currying-functions.html" rel="nofollow">函数柯里化(Function Currying) </a></td> 
  </tr> 
 </tbody> 
</table>

\[http://www.runoob.com\] [  
][Link 1]

[皮皮blog][Link 1]

# Scala 闭包 #

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

如下面这段匿名的函数：

val multiplier = (i:Int) => i * 10

函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：

val multiplier = (i:Int) => i * factor

在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码：

var factor = 3  
    val multiplier = (i:Int) => i * factor

这里我们引入一个自由变量 factor，这个变量定义在函数外面。

这样定义的函数变量 multiplier 成为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

from: [http://blog.csdn.net/pipisorry/article/details/52902271][blog.csdn.net_pipisorry_article_details_52902271]

ref: \[[Scala学习笔记之Scala函数及函数式编程 ][Scala_Scala_]\]

\[[Scala Tutorial][]\]

[blog.csdn.net_pipisorry_article_details_52902271]: http://blog.csdn.net/pipisorry/article/details/52902271
[Link 1]: http://blog.csdn.net/pipisorry
[Scala_Scala_]: http://blog.csdn.net/ssjssh/article/details/12126477
[Scala Tutorial]: https://www.tutorialspoint.com/scala/index.htm