http://www.runoob.com/scala/scala-functions.html scala函式的定義，注意一些特殊函式的書寫

1. =>符號

var equalRight = (x:Int) => x + 1  //--equalRight is <function1>   匿名函式

類似於轉化符號，=>指明這個函式把左邊的東西（任何整數x）轉變成右邊的東西（x + 1）。所以，這是一個把任何整數x對映為x + 1的函式。也可以進行型別的強轉．

－－－該解釋尚不清晰，需要進一步發現。

2.<- 迴圈遍歷（遞迴）＋引數的可變性×

def printStrings
 
(args: String*) = {
  var i: Int = 0
for (arg <- args) {
    println("Arg value[" + i + "] = " + arg)
    i = i + 1
}
}

函式呼叫：

printStrings("ahoBs", "abo", "alBo")

結果：

Arg value[2] = alBo

3.字串拼接 ++=

/**
  *  String 物件是不可變的，如果你需要建立一個可以修改的字串，可以使用 String Builder 類
 
  */
def StringTest(): Unit ={
    val hello:String = "hello world!" //String 物件不可變
var len = hello.length
    val buf = new StringBuilder
    buf += 'a'
buf ++= "bcdef"                  //++=
println("hello say :" + hello)
    println("hello's len is "+ len)
    println("buf is " + buf.toString())
  }

函式：

1.高階函式 http://www.runoob.com/scala/higher-order-functions.html

高階函式（Higher-Order Function）就是操作其他函式的函式。
Scala 中允許使用高階函式, 高階函式可以使用其他函式作為引數，或者使用函式作為輸出結果。
以下例項中，apply() 函式使用了另外一個函式 f 和 值 v 作為引數，而函式 f 又呼叫了引數 v：

// 函式 f 和 值 v 作為引數，而函式 f 又呼叫了引數 v
def apply(f:Int => String,v:Int) = f(v)
def layout[A](x:A) = "[" + x.toString() + "]"

println( apply( layout, 10) )

結果：

［10］

2.匿名函式 http://www.runoob.com/scala/anonymous-functions.html

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)-1
同樣我們可以在匿名函式中定義多個引數：
var mul = (x: Int, y: Int) => x*y
mul 現在可作為一個函式，使用方式如下：
println(mul(3, 4))
我們也可以不給匿名函式設定引數，如下所示：
var userDir = () => { System.getProperty("user.dir") }
userDir 現在可作為一個函式，使用方式如下：
println( userDir() )
例項
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
將以上程式碼保持到 Demo.scala 檔案中，執行以下命令：
$ scalac Demo.scala
$ scala Demo
輸出結果為：
multiplier(1) value = 3
multiplier(2) value = 6

3.函式柯里化(Currying)  http://www.runoob.com/scala/currying-functions.html

柯里化(Currying)指的是將原來接受兩個引數的函式變成新的接受一個引數的函式的過程。新的函式返回一個以原有第二個引數為引數的函式。.

例項

首先我們定義一個函式:

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

那麼我們應用的時候，應該是這樣用：add(1,2)

現在我們把這個函式變一下形：

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

那麼我們應用的時候，應該是這樣用：add(1)(2),最後結果都一樣是3，這種方式（過程）就叫柯里化。

實現過程

add(1)(2) 實際上是依次呼叫兩個普通函式（非柯里化函式），第一次呼叫使用一個引數 x，返回一個函式型別的值，第二次使用引數y呼叫這個函式型別的值。

實質上最先演變成這樣一個方法：

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

那麼這個函式是什麼意思呢？ 接收一個x為引數，返回一個匿名函式，該匿名函式的定義是：接收一個Int型引數y，函式體為x+y。現在我們來對這個方法進行呼叫。

val result = add(1)

返回一個result，那result的值應該是一個匿名函式：(y:Int)=>1+y

所以為了得到結果，我們繼續呼叫result。

val sum = result(2)

最後打印出來的結果就是3。

完整例項

下面是一個完整例項：

objectTest{def main(args:Array[String]){
      val str1:String="Hello, "
      val str2:String="Scala!"
      println("str1 + str2 = "+  strcat(str1)(str2))}def strcat(s1:String)(s2:String)={
      s1 + s2
   }}

執行以上程式碼，輸出結果為：

$ scalac Test.scala
$ scala Test
str1 + str2 =Hello,Scala!