Scala 高阶函数

高阶函数是一种接受函数作为参数或返回函数的函数。换句话说，我们可以称之为能与函数一起工作的函数为高阶函数。

高阶函数允许你创建函数组合、lambda函数或匿名函数等。

让我们看一个例子。

Scala 示例：将一个函数作为参数传递给另一个函数

object MainObject {
   def main(args: Array[String]) = {
     functionExample(25, multiplyBy2)                   // Passing a function as parameter
    }
    def functionExample(a:Int, f:Int=>AnyVal):Unit = {
        println(f(a))                                   // Calling that function 
    }
    def multiplyBy2(a:Int):Int = {
        a*2
    }
}

结果：

60

Scala示例：函数组合

在Scala中，函数可以由其他函数组合而成。这是一个由两个组合函数应用而成的组合过程。

让我们看一个例子。

object MainObject {
   def main(args: Array[String]) = {
     var result = multiplyBy2(add2(10))      // Function composition
     println(result)
    }
    def add2(a:Int):Int = {
        a+2
    }

    def multiplyBy2(a:Int):Int = {
        a*2
    }
}

输出：

24

Scala匿名（lambda）函数

匿名函数是一个没有名称但作为函数工作的函数。当您不想在后面重复使用它时，创建匿名函数是一个不错的选择。

您在Scala中可以使用=>（箭头）或_（下划线）通配符来创建匿名函数。

让我们来看一个例子。

Scala匿名函数示例

object MainObject {
   def main(args: Array[String]) = {
     var result1 = (a:Int, b:Int) => a+b        // Anonymous function by using => (rocket)
     var result2 = (_:Int)+(_:Int)              // Anonymous function by using _ (underscore) wild card
     println(result1(10,10))
     println(result2(10,10))
    }
}

输出：

结果：

20
20

Scala多行表达式

在多行中书写的表达式被称为多行表达式。在Scala中，使用多行表达式时要小心。

下面的程序说明了如果我们将一个表达式分成多行，Scala编译器会抛出警告信息。

Scala多行表达式示例

def add1(a:Int, b:Int) = {
        a
        +b
    }

上面的程序不会对完整的表达式进行求值，只会返回 b。因此，在使用多行表达式时要小心。

输出结果：

MainObject.scala:3: warning: a pure expression does nothing in statement 
position; you may be omitting necessary parentheses
        a
        ^
one warning found

10

您可以采用以下方法来避免上述问题。

Scala示例多行表达式

object MainObject {
    def add2(a:Int, b:Int) = {
        a+
        b
    }
    def add3(a:Int, b:Int) = {
        (a
        +b)
    }
    def main(args: Array[String]) = {
        var result2 = add2(10,10)
        var result3 = add3(10,10)
        println(result2+"\n"+result3)
    }
}

输出：

20
20

Scala函数柯里化

在Scala中，方法可以有多个参数列表。当一个方法被调用时，如果缺少一部分参数列表，则会生成一个以缺少的参数列表作为参数的函数。

换句话说，柯里化是将接受多个参数的函数转化为接受单个参数的函数的技术。

Scala函数柯里化示例

object MainObject {
    def add(a:Int)(b:Int) = {
        a+b
    }
    def main(args: Array[String]) = {
        var result = add(10)(10)
        println("10 + 10 = "+result)
        var addIt = add(10)_
        var result2 = addIt(3)
        println("10 + 3 = "+result2)
    }
}

输出：

20

Scala嵌套函数

Scala是一种一流的函数语言，这意味着它允许你传递函数、返回函数、组合函数、嵌套函数等等。下面的例子介绍了如何定义和调用嵌套函数。

Scala嵌套函数示例

object MainObject {
    def add(a:Int, b:Int, c:Int) = {
        def add2(x:Int,y:Int) = {
            x+y
        }
        add2(a,add2(b,c))
    }
    def main(args: Array[String]) = {
        var result = add(10,10,10)
        println(result)
    }
}

结果：

30

Scala变长参数的函数

在Scala中，你可以定义带有变长参数的函数。这允许你在调用函数时传递任意数量的参数。

让我们看一个例子。

Scala例子：带有变长参数的函数

def add(args: Int*) = {
    var sum = 0;
    for(a <- args) sum+=a
    sum
}
var sum = add(1,2,3,4,5,6,7,8,9);
println(sum);

输出：

45