Scala函数

函数定义

方法定义由一个def 关键字开始，紧接着是可选的参数列表，一个冒号“：” 和方法的返回类型，一个等于号“=”，最后是方法的主体。
Scala 函数定义格式如下（参考备注的例子）：
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}

函数调用

Scala 提供了多种不同的函数调用方式，以下是调用方法的标准格式：
functionName( 参数列表 )
如果函数使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：[instance.]functionName( 参数列表 )

函数的使用

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

匿名函数

下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:
var inc = (x:Int) => x+1
上述定义的匿名函数，其实是下面这种写法的简写:
def add2 = new Function1[Int,Int]{
def apply(x:Int):Int = x+1;
}
以上实例的 inc 现在可作为一个函数，使用方式如下:
var x = inc(7)-1var userDir = () => { System.getProperty(“user.dir”) }
使用方式如下:println( userDir() )

通过函数名调用

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

object Test { 
    def main(args: Array[String]) { 
        printInt(b=5, a=7); 
    } 
    def printInt( a:Int, b:Int ) = { 
        println("Value of a : " + a ); 
        println("Value of b : " + b ); 
    }
    //结果为:
    //Value of :7
    //Value of :5
}

默认参数值

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

object Test { 
    def main(args: Array[String]) { 
        println( "返回值 : " + addInt() );
    } 
    def addInt( a:Int=5, b:Int=7 ) : Int = { 
        var sum:Int = 0 
        sum = a + b 
        return sum 
    }
    //返回值为12
}

可变参数

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。例如：

object Test { 
    def main(args: Array[String]) { 
        printStrings("Runoob", "Scala", "Python");
    } 
    def printStrings( args:String* ) = { 
        var i : Int = 0; 
        for( arg <- args ){ 
        println("Arg value[" + i + "] = " + arg ); 
        i = i + 1; 
        } 
    }
    /*输出结果为:Arg value[0] = Runoob 
                Arg value[1] = Scala 
                Arg value[2] = Python
    */
}

递归函数

递归函数在函数式编程的语言中起着重要的作用，递归函数意味着函数可以调用它本身，以下实例使用递归函数来计算阶乘。例如：

object Test { 
    def main(args: Array[String]) { 
        for (i <- 1 to 8) 
        println(i + " 的阶乘为: = " + factorial(i) )
    } 
    def factorial(n: BigInt): BigInt = { 
        if (n <= 1) 
            1 
        else 
            n * factorial(n - 1) 
    }   
}

函数的嵌套

可以在 Scala 函数内定义函数，定义在函数内的函数称之为局部函数。以下实例我们实现阶乘运算，并使用内嵌函数：

object Test { 
    def main(args: Array[String]) { 
        println( factorial(0) ) 
        println( factorial(1) ) 
        println( factorial(2) ) 
    } 
    def factorial(i: Int): Int = { 
        def fact(i: Int, accumulator: Int): Int = { 
            if (i <= 1) 
                accumulator 
            else 
                fact(i - 1, i * accumulator) 
        } 
        fact(i, 1) 
    }   
}

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。如下面这段匿名的函数：
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 成为一个”闭包”，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

模式匹配

模式匹配是Scala函数值和闭包后第二大应用功能。Scala为模式匹配提供了极大的支持，处理消息。
模式匹配包括一系列备选项，每个替代项以关键字大小写为单位。每个替代方案包括一个模式和一个或多个表达式，如果模式匹配，将会进行评估计算。箭头符号=>将模式与表达式分离。尝试以下示例程序，它显示匹配的整数值：

object Test { 
    def main(args: Array[String]) { 
        println(matchTest(3))
    } 
    def matchTest(x: Int): String = x match { 
        case 1 => "one" 
        case 2 => "two" 
        case _ => "many" 
    }
}

具有case语句的块定义了一个将整数映射到字符串的函数。match关键字提供了一种方便的方式来应用一个函数(如上面的模式匹配函数)到一个对象。
其中还支持其中的值与不同类型的模式相匹配，见下例:

object Demo { 
    def main(args: Array[String]) { 
        println(matchTest("two")) 
        println(matchTest("test")) 
        println(matchTest(1)) 
    } 
    def matchTest(x: Any): Any = x match { 
        case 1 => "one" 
        case "two" => 2 
        case y: Int => "scala.Int" 
        case _ => "many" 
    } 
}