课程表

Scala课程

工具箱
速查手册

Scala 函数

当前位置：免费教程 » Java相关 » Scala

函数是一组一起执行一个任务的语句。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。

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

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

函数声明

Scala 函数声明格式如下：

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

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

函数定义

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

Scala 函数定义格式如下：

  1. def functionName ([参数列表]) : [return type] = {
  2.    function body
  3.    return [expr]
  4. }

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

以下函数的功能是将两个传入的参数相加并求和：

  1. object add{
  2.    def addInt( a:Int, b:Int ) : Int = {
  3.       var sum:Int = 0
  4.       sum = a + b
  5.  
  6.       return sum
  7.    }
  8. }

如果函数没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：

  1. object Hello{
  2.    def printMe( ) : Unit = {
  3.       println("Hello, Scala!")
  4.    }
  5. }

函数调用

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

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

  1. functionName( 参数列表 )

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

  1. [instance.]functionName( 参数列表 )

以上实例演示了定义与调用函数的实例:

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         println( "Returned Value : " + addInt(5,7) );
  4.    }
  5.    def addInt( a:Int, b:Int ) : Int = {
  6.       var sum:Int = 0
  7.       sum = a + b
  8.  
  9.       return sum
  10.    }
  11. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala 
  2. $ scala Test
  3. Returned Value : 12

Scala也是一种函数式语言，所以函数是 Scala 语言的核心。以下一些函数概念有助于我们更好的理解 Scala 编程：

函数概念解析接案例
函数传名调用(Call-by-Name) 指定函数参数名
函数 - 可变参数 递归函数
默认参数值 高阶函数
内嵌函数 匿名函数
偏应用函数 函数柯里化(Function Currying)

Scala 函数传名调用(call-by-name)

Scala的解释器在解析函数参数(function arguments)时有两种方式：

  • 传值调用（call-by-value）：先计算参数表达式的值，再应用到函数内部；
  • 传名调用（call-by-name）：将未计算的参数表达式直接应用到函数内部

在进入函数内部前，传值调用方式就已经将参数表达式的值计算完毕，而传名调用是在函数内部进行参数表达式的值计算的。

这就造成了一种现象，每次使用传名调用时，解释器都会计算一次表达式的值。

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         delayed(time());
  4.    }
  5.  
  6.    def time() = {
  7.       println("获取时间，单位为纳秒")
  8.       System.nanoTime
  9.    }
  10.    def delayed( t: => Long ) = {
  11.       println("在 delayed 方法内")
  12.       println("参数： " + t)
  13.       t
  14.    }
  15. }

在线运行实例

以上实例中我们声明了 delayed 方法， 该方法在变量名和变量类型使用 => 符号来设置传名调用。执行以上代码，输出结果类似如下（时间部分会有不同）：

  1. $ scalac Test.scala 
  2. $ scala Test
  3. 在 delayed 方法内
  4. 获取时间，单位为纳秒
  5. 参数： 241550840475831
  6. 获取时间，单位为纳秒

实例中 delay 方法打印了一条信息表示进入了该方法，接着 delay 方法打印接收到的值，最后再返回 t。

指定函数参数名

一般情况下函数调用参数，就按照函数定义时的参数顺序一个个传递。但是我们也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数，实例如下：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         printInt(b=5, a=7);
  4.    }
  5.    def printInt( a:Int, b:Int ) = {
  6.       println("Value of a : " + a );
  7.       println("Value of b : " + b );
  8.    }
  9. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. Value of a :  7
  4. Value of b :  5

可变参数

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。

Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。例如：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         printStrings("W3xue", "Scala", "Python");
  4.    }
  5.    def printStrings( args:String* ) = {
  6.       var i : Int = 0;
  7.       for( arg <- args ){
  8.          println("Arg value[" + i + "] = " + arg );
  9.          i = i + 1;
  10.       }
  11.    }
  12. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. Arg value[0] = W3xue
  4. Arg value[1] = Scala
  5. Arg value[2] = Python

递归函数

递归函数在函数式编程的语言中起着重要的作用。

Scala 同样支持递归函数。

递归函数意味着函数可以调用它本身。

以上实例使用递归函数来计算阶乘：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       for (i <- 1 to 10)
  4.          println(i + " 的阶乘为: = " + factorial(i) )
  5.    }
  6.    
  7.    def factorial(n: BigInt): BigInt = {  
  8.       if (n <= 1)
  9.          1  
  10.       else    
  11.       n * factorial(n - 1)
  12.    }
  13. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. 1 的阶乘为: = 1
  4. 2 的阶乘为: = 2
  5. 3 的阶乘为: = 6
  6. 4 的阶乘为: = 24
  7. 5 的阶乘为: = 120
  8. 6 的阶乘为: = 720
  9. 7 的阶乘为: = 5040
  10. 8 的阶乘为: = 40320
  11. 9 的阶乘为: = 362880
  12. 10 的阶乘为: = 3628800

默认参数值

Scala 可以为函数参数指定默认参数值，使用了默认参数，你在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。实例如下： 

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         println( "返回值 : " + addInt() );
  4.    }
  5.    def addInt( a:Int=5, b:Int=7 ) : Int = {
  6.       var sum:Int = 0
  7.       sum = a + b
  8.  
  9.       return sum
  10.    }
  11. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. 返回值 : 12

高阶函数

高阶函数（Higher-Order Function）就是操作其他函数的函数。

Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。

以下实例中，apply() 函数使用了另外一个函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.  
  4.       println( apply( layout, 10) )
  5.  
  6.    }
  7.    // 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v
  8.    def apply(f: Int => String, v: Int) = f(v)
  9.  
  10.    def layout[A](x: A) = "[" + x.toString() + "]"
  11.    
  12. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. [10]

函数嵌套

我么可以在 Scala 函数内定义函数，定义在函数内的函数称之为局部函数。

以下实例我们实现阶乘运算，并使用内嵌函数：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       println( factorial(0) )
  4.       println( factorial(1) )
  5.       println( factorial(2) )
  6.       println( factorial(3) )
  7.    }
  8.  
  9.    def factorial(i: Int): Int = {
  10.       def fact(i: Int, accumulator: Int): Int = {
  11.          if (i <= 1)
  12.             accumulator
  13.          else
  14.             fact(i - 1, i * accumulator)
  15.       }
  16.       fact(i, 1)
  17.    }
  18. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. 1
  4. 1
  5. 2
  6. 6

匿名函数

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。

使用匿名函数后，我们的代码变得更简洁了。

下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:

  1. var inc = (x:Int) => x+1

上述定义的匿名函数，其实是下面这种写法的简写：

  1. def add2 = new Function1[Int,Int]{  
  2. 	def apply(x:Int):Int = x+1;  
  3. }

以上实例的 inc 现在可作为一个函数，使用方式如下：

  1. var x = inc(7)-1

同样我们可以在匿名函数中定义多个参数：

  1. var mul = (x: Int, y: Int) => x*y

mul 现在可作为一个函数，使用方式如下：

  1. println(mul(3, 4))

我们也可以不给匿名函数设置参数，如下所示：

  1. var userDir = () => { System.getProperty("user.dir") }

userDir 现在可作为一个函数，使用方式如下：

  1. println( userDir() )

实例

  1. object Demo {
  2.    def main(args: Array[String]) {
  3.       println( "multiplier(1) value = " +  multiplier(1) )
  4.       println( "multiplier(2) value = " +  multiplier(2) )
  5.    }
  6.    var factor = 3
  7.    val multiplier = (i:Int) => i * factor
  8. }

将以上代码保持到 Demo.scala 文件中，执行以下命令：

  1. $ scalac Demo.scala
  2. $ scala Demo

在线运行实例

输出结果为：

  1. multiplier(1) value = 3
  2. multiplier(2) value = 6

偏应用函数

Scala 偏应用函数是一种表达式，你不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

如下实例，我们打印日志信息：

  1. import java.util.Date
  2.  
  3. object Test {
  4.    def main(args: Array[String]) {
  5.       val date = new Date
  6.       log(date, "message1" )
  7.       Thread.sleep(1000)
  8.       log(date, "message2" )
  9.       Thread.sleep(1000)
  10.       log(date, "message3" )
  11.    }
  12.  
  13.    def log(date: Date, message: String)  = {
  14.      println(date + "----" + message)
  15.    }
  16. }

执行以上代码，输出结果类似如下：

  1. $ scalac Test.scala
  2. $ scala Test
  3. Mon Dec 02 12:52:41 CST 2013----message1
  4. Mon Dec 02 12:52:41 CST 2013----message2
  5. Mon Dec 02 12:52:41 CST 2013----message3

实例中，log() 方法接收两个参数：date 和 message。我们在程序执行时调用了三次，参数 date 值都相同，message 不同。

我们可以使用偏应用函数优化以上方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量。以上实例修改如下：

  1. import java.util.Date
  2.  
  3. object Test {
  4.    def main(args: Array[String]) {
  5.       val date = new Date
  6.       val logWithDateBound = log(date, _ : String)
  7.  
  8.       logWithDateBound("message1" )
  9.       Thread.sleep(1000)
  10.       logWithDateBound("message2" )
  11.       Thread.sleep(1000)
  12.       logWithDateBound("message3" )
  13.    }
  14.  
  15.    def log(date: Date, message: String)  = {
  16.      println(date + "----" + message)
  17.    }
  18. }

执行以上代码，输出结果类似如下：

  1. $ scalac Test.scala
  2. $ scala Test
  3. Mon Dec 02 12:53:56 CST 2013----message1
  4. Mon Dec 02 12:53:56 CST 2013----message2
  5. Mon Dec 02 12:53:56 CST 2013----message3

函数柯里化(Currying)

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

实例

首先我们定义一个函数:

  1. def add(x:Int,y:Int)=x+y

那么我们应用的时候，应该是这样用：add(1,2)

现在我们把这个函数变一下形：

  1. def add(x:Int)(y:Int) = x + y

那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。

实现过程

add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

实质上最先演变成这样一个方法：

  1. def add(x:Int)=(y:Int)=>x+y

那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。

  1. val result = add(1)

返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y

所以为了得到结果，我们继续调用result。

  1. val sum = result(2)

最后打印出来的结果就是3。

完整实例

下面是一个完整实例：

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       val str1:String = "Hello, "
  4.       val str2:String = "Scala!"
  5.       println( "str1 + str2 = " +  strcat(str1)(str2) )
  6.    }
  7.  
  8.    def strcat(s1: String)(s2: String) = {
  9.       s1 + s2
  10.    }
  11. }

在线运行实例

执行以上代码，输出结果为：

  1. $ scalac Test.scala
  2. $ scala Test
  3. str1 + str2 = Hello, Scala!
转载本站内容时，请务必注明来自W3xue，违者必究。
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
皖ICP备17017327号-2　皖公网安备34020702000426号