kotlin 高阶函数
In this tutorial, we’ll be looking into kotlin higher-order functions and lambda expressions in detail. At the same time, we’ll explore function references, anonymous functions, and closures too.
在本教程中,我们将详细研究kotlin高阶函数和lambda表达式。 同时,我们还将探索函数引用,匿名函数和闭包。
Kotlin supports functional programming. High order functions have the ability to pass a function as an argument or use it as the return value. Let’s see this through examples.
Kotlin支持功能编程。 高阶函数可以将函数作为参数传递或将其用作返回值。 让我们通过示例来看一下。
Functions in Kotlin are types.
()->String
is a type that takes no parameters and returns a string.
(String)->String
is a type that takes a string argument and returns a string argument.
Kotlin中的函数是类型。
()->String
是一种不带参数且返回字符串的类型。
(String)->String
是一种接受字符串参数并返回字符串参数的类型。
Lambda表达式是函数文字,可以帮助我们以简短的方式编写函数。 它们为我们提供了一种紧凑的代码编写方式。 让我们定义一个lambda表达式以查看函数如何充当类型。
fun main(args: Array) {
var lambdaFunction :(String)->Unit = {s:String -> println(s)}
lambdaFunction("Kotlin Lambda Functions")
//or
lambdaFunction = {println(it)}
lambdaFunction("Kotlin Lambda Functions Concise")
val noArgFunction : () -> Unit ={ println("Another function")}
noArgFunction()
}
//Following is printed on the console.
//Kotlin Lambda Functions
//Kotlin Lambda Functions Concise
//Another function
lambdaFunction
property has a function as its type. The right-hand side is where the function is declared.
lambdaFunction
属性具有一个函数作为其类型。 右侧是函数的声明位置。
it
is used to access parameter values in the body of the lambda expression.
it
用于访问lambda表达式主体中的参数值。
We can pass a function as a parameter inside another function too using references as shown below.
我们也可以使用引用将函数作为参数传递给另一个函数,如下所示。
Such functions are known as High Order Functions.
这样的函数称为高阶函数 。
fun main(args: Array) {
var printFunction: (String) -> Unit = { println(it) }
functionReferencesExample("JournalDev.com", printFunction)
}
fun functionReferencesExample(str: String, expression: (String) -> Unit) {
print("Welcome To Kotlin Series @")
expression(str)
}
To pass a function as an argument inside another function we need to use the notation ::
. Following code snippet demonstrates an example on the same.
要将函数作为参数传递给另一个函数,我们需要使用符号::
。 下面的代码片段在同一示例上演示了一个示例。
fun main(args: Array) {
functionReferencesExample("JournalDev.com", ::printFunction)
}
fun functionReferencesExample(str: String, expression: (String) -> Unit) {
print("Welcome To Kotlin Series @")
expression(str)
}
fun printFunction(str: String) {
println(str)
}
Note: We’ll look at High order functions and lambda expressions in detail in a later tutorial.
注意 :我们将在以后的教程中详细介绍高阶函数和lambda表达式。
A Lambda expression can be passed inside a higher order function parameter as shown below.
Lambda表达式可以在高阶函数参数中传递,如下所示。
fun main(args: Array) {
printMe({ println("Lambda Inside a function")}) //prints Lambda Inside a function
}
fun printMe(string1: () -> Unit) {
string1()
}
The lambda expression as a parameter runs as a function inside another function.
lambda表达式作为参数在另一个函数中作为函数运行。
Another example demonstrates using lambda expressions inside print function.
另一个示例演示了在print函数内部使用lambda表达式。
fun main(args: Array) {
println("Let's invoke a lambda function ${returnMe { "return Me " + "function" }} here")
}
fun returnMe(string: ()->String) : String
{
return string()
}
//Prints
//Let's invoke a lambda function return Me function here
Typealiases provide an alternative name for a type.
Instead of typing the function type every time when defining a property, we can use typealias
as shown below.
Typealiases为类型提供了备用名称。
不必在定义属性时每次都键入函数类型,而是可以使用如下所示的类型typealias
。
fun main(args: Array) {
var printFunction: MyFirstAlias = { println(it) }
}
typealias MyFirstAlias = (String)->Unit
typeAlias Username = String
This definitely enhances the readability of the code.
这无疑提高了代码的可读性。
We’ve seen that lambda expressions can’t explicitly specify a return type as illustrated below.
我们已经看到,lambda表达式无法显式指定返回类型,如下所示。
var sum = { a: Int, b: Int -> a + b }
var result = sum(2,3) //result is an int 5
In order to set the return types explicitly, we can use Annoymous functions.
An annoymous function doesn’t require a name.
为了显式设置返回类型,我们可以使用Annoymous函数。
异常函数不需要名称。
fun main(args: Array) {
//Defining
val annoSum = fun(x: Int, y: Int): Int = x + y
//Invoking
print(annoSum(2,3)) //5
}
If the parameter/return type of the annoymous function isn’t defined, it can be inferred just like normal functions.
如果未定义匿名函数的参数/返回类型,则可以像普通函数一样进行推断。
Let’s use Anonymous functions inside standard library high order functions.
让我们在标准库高阶函数中使用匿名函数。
var myList = listOf(1,2,5,7,6,10)
myList = myList.filter(fun(item) = (item%2 ==0) )
println(myList)
filter
is a higher order function that checks the given condition over each of the list items.
In the above code, it checks for odd/even over each list integer element.
filter
是一个高阶函数,用于检查每个列表项上的给定条件。
在上面的代码中,它检查每个列表整数元素的奇/偶数。
Note: There are plenty of standard library functions. We’ll look at them and there use cases in a later tutorial.
注意:有很多标准库函数。 我们将在以后的教程中研究它们以及用例。
Closures are functions that can access and modify properties defined outside the scope of the function.
The following closure function is a high order function that calculates the sum of all elements of the list and updates a property defined outside the closure.
闭包是可以访问和修改在函数范围之外定义的属性的函数。
下面的闭包函数是一个高阶函数,它计算列表中所有元素的总和并更新在闭包外部定义的属性。
var res = 0
myList = listOf(1,2,3,4,5,6,7,8,9,10)
myList.forEach { res+=it }
println(res) //prints 55
This brings an end to this tutorial. We’ll be looking at the standard library higher-order functions in a later tutorial. You can download the sample code of the above tutorial from the link below.
本教程到此结束。 在后面的教程中,我们将研究标准库的高阶函数。 您可以从下面的链接下载上述教程的示例代码。
翻译自: https://www.journaldev.com/18835/kotlin-lambda-higher-order-functions
kotlin 高阶函数