Kotlin 高阶函数

Kotlin 语言对函数式编程有极好的支持。 Kotlin 函数可以存储在变量和数据结构中，作为参数传递给其他高阶函数并从其他高阶函数返回。

高阶函数——

在 Kotlin 中，可以接受函数作为参数或可以返回函数的函数称为高阶函数。我们将传递匿名函数或 lambda，而不是整数、字符串或数组作为函数的参数。为方便起见，在 Kotlin 函数中经常将 lambda 作为参数传递。

将 lambda 表达式作为参数传递给高阶函数–

我们可以将 lambda 表达式作为参数传递给 Higher-Order 函数。
可以传递两种类型的 lambda 表达式-

• 返回 Unit 的 Lambda 表达式
• 返回任何值整数、字符串等的 Lambda 表达式

返回 Unit- 的 lambda 表达式的 Kotlin 程序

Kotlin

// lambda expression
var lambda = {println("GeeksforGeeks: A Computer Science portal for Geeks") }
      // higher-order function
fun higherfunc( lmbd: () -> Unit ) {     // accepting lambda as parameter
    lmbd()                               //invokes lambda expression
}
fun main(args: Array) {
     //invoke higher-order function
    higherfunc(lambda)                 // passing lambda as parameter
}

输出：

GeeksforGeeks: A Computer Science portal for Geeks

解释：
让我们一步一步理解上面的程序：
在顶部，我们定义了一个包含 print() 的 lambda 表达式，用于将字符串打印到标准输出。

var lambda = {println("GeeksforGeeks: A Computer Science portal for Geeks") } 

然后，我们定义一个包含一个参数的高阶函数。

lmbd: () -> Unit

lmbd是接收 lambda 参数的本地名称。
()表示该函数不接受任何参数。
Unit表示该函数不返回任何值。
在 main函数中，我们通过将 lambda 表达式作为参数传递来调用高阶函数。

higherfunc(lambda)

返回整数值的 lambda 表达式的 Kotlin 程序 –

科特林

// lambda expression
var lambda = {a: Int , b: Int -> a + b }
    // higher order function
fun higherfunc( lmbd: (Int, Int) -> Int) {      // accepting lambda as parameter
         
    var result = lmbd(2,4)    // invokes the lambda expression by passing parameters                   
    println("The sum of two numbers is: $result")
}
 
fun main(args: Array) {
    higherfunc(lambda)           //passing lambda as parameter
}

输出：

The sum of two numbers is: 6

解释：
让我们一步一步理解上面的程序：
在顶部，我们定义了一个返回整数值的 lambda 表达式。

var lambda = {a: Int , b: Int -> a + b }

然后，我们定义了接受 lambda 表达式作为参数的高阶函数。

lmbd: (Int, Int) -> Int

lmbd是接收 lambda 参数的本地名称。
(Int,Int)表示该函数接受两个整数类型参数。
-> Int表示该函数返回一个整数值。
在 main函数中，我们通过传递 lambda 作为参数来调用高阶函数。

higherfunc(lambda)

将函数作为参数传递给高阶函数——

我们可以在高阶函数中将函数作为参数传递。
可以传递两种类型的函数-

• 返回单位的函数
• 返回任何值整数、字符串等的函数

传递函数的 Kotlin 程序返回 Unit-

科特林

// regular function definition
fun printMe(s:String): Unit{
    println(s)
}
   // higher-order function definition
fun higherfunc( str : String, myfunc: (String) -> Unit){
   // invoke regular function using local name
    myfunc(str)
}
fun main(args: Array) {
    // invoke higher-order function
    higherfunc("GeeksforGeeks: A Computer Science portal for Geeks",::printMe)
}

输出：

GeeksforGeeks: A Computer Science portal for Geeks

解释：
在顶部，我们定义了一个常规函数printMe()，它接受 String 类型的参数并返回 Unit。

fun printMe(s:String): Unit

(s: String)是唯一的参数
单位代表返回类型
然后，我们将高阶函数定义为

fun higherfunc( str : String, myfunc: (String) -> Unit)

它接收两个参数，一个是字符串类型，另一个是函数
str：String表示字符串参数
myfunc: (String) -> Unit表示它接受函数作为返回 Unit 的参数。
从 main函数，通过将字符串和函数作为参数传递来调用更高的函数。

higherfunc("GeeksforGeeks: A Computer Science portal for Geeks",::printMe)

传递函数的 Kotlin 程序返回整数值-

科特林

// regular function definition
fun add(a: Int, b: Int): Int{
    var sum = a + b
    return sum
}
    // higher-order function definition
fun higherfunc(addfunc:(Int,Int)-> Int){
    // invoke regular function using local name
    var result = addfunc(3,6)
    print("The sum of two numbers is: $result")
}
fun main(args: Array) {
    // invoke higher-order function
    higherfunc(::add)
}

输出：

The sum of two numbers is: 9

解释：
在顶部，我们将常规函数定义为

fun add(a: Int, b: Int): Int{
    var sum = a + b
    return sum
}

它接受两个整数类型的参数，并返回两个整数的和
然后，我们将高阶函数定义为

fun higherfunc(addfunc:(Int,Int)-> Int)

它接受一个包含两个参数的函数和
通过传递参数调用常规函数addfunc(3,6)。
在 main函数中，我们通过将常规函数作为参数传递来调用高阶函数

higherfunc(::add)

从高阶函数返回一个函数

我们可以从高阶函数。在返回函数时，我们必须在高阶函数的返回类型中指定常规函数的参数类型和返回类型。

返回另一个函数的函数的 Kotlin 程序 -

科特林

// function declaration
fun mul(a: Int, b: Int): Int{
    return a*b
}
    //higher-order function declaration
fun higherfunc() : ((Int,Int)-> Int){
    return ::mul
}
fun main(args: Array) {
     // invoke function and store the returned function into a variable
    val multiply = higherfunc() 
    // invokes the mul() function by passing arguments
    val result = multiply(2,4)  
    println("The multiplication of two numbers is: $result")
}

输出：

The multiplication of two numbers is: 8

解释：
在程序的顶部，我们定义了 mul()函数，它接受两个参数，它的返回类型也是一个整数。

fun mul(a: Int, b: Int): Int

然后，我们定义返回类型为函数。

fun higherfunc5() : ((Int,Int)-> Int){
    return ::mul
}

::mul表示它返回 mul()函数
(Int,Int)表示 mul 接受两个整数类型参数
Int表示 mul 返回一个整数值。
在 main函数中，我们调用了返回另一个函数并将其存储在变量 multiply 中的更高层函数。

val multiply = higherfunc()

然后我们通过传递两个参数使用局部变量 multiply(2,4) 调用 mul()函数。