Kotlin 函数 与 lambda 表达式(Kotlin function and lambda expression)

一、函数

代码块函数体:

fun sum(x: Int, y: Int): Int {
    return x + y
}

表达式函数体:

fun sum(x: Int, y: Int) = x + y

使用表达式函数体,一般情况下可以不声明返回值类型。在一些诸如递归等复杂情况下,即使是使用表达式函数体,也必须显示声明返回值类型。

总结:

函数参数必须显示声明类型
非表达式函数体,函数参数必须显示声明类型, 返回值除了类型是 Unit,可以省略,其它情况,返回值都必须显示声明类型
如果它是一个递归的函数,必须显示声明参数和返回值类型
如果它是一个公有方法,为了代码的可读性,尽量显示声明函数参数和返回值类型

总结:

  • 函数参数必须显示声明类型
  • 非表达式函数体,函数参数必须显示声明类型, 返回值除了类型是 Unit,可以省略,其它情况,返回值都必须显示声明类型
  • 如果它是一个递归的函数,必须显示声明参数和返回值类型
  • 如果它是一个公有方法,为了代码的可读性,尽量显示声明函数参数和返回值类型

二、函数类型

Kotlin 中,函数类型的格式如下:

() -> Unit

Kotlin 中,函数类型声明必须遵循以下几点:

Kotlin 中,函数类型声明必须遵循以下几点:

通过 -> 符号来组织参数类型和返回值类型。左边是参数类型,右边是返回值类型
必须用一个括号来包裹参数类型
返回值类型即使是 Unit, 也必须显示声明。

  • 通过 -> 符号来组织参数类型和返回值类型。左边是参数类型,右边是返回值类型
  • 必须用一个括号来包裹参数类型
  • 返回值类型即使是 Unit, 也必须显示声明。

使用对某个类的方法进行引用,比如:

::
class A {
    fun test()
}

我们可以使用如下方式保持对 test() 方法的引用

val a = A () // 创建类的对象
val f = a::test // 通过对象引用方法
f.invike() // 调用方法

三、lambda 表达式

val sum: (Int, Int) -> Int = {x: Int, y: Int -> x + y}

由于支持类型推导,可以简化为

val sum: (Int, Int) -> Int = {x, y -> x + y}

或者:

val sum = {x: Int, y: Int -> x + y}

lambda 表达式语法:

lambda 表达式必须通过 {} 来包裹
如果 lambda 声明了参数部分的类型,且返回值支持类型推导,则 lambda 表达式变量就可以省略函数类型声明
如果 lambda 变量声明了函数类型,那么 lambda 表达式的参数部分的类型就可以省略
如果 lambda 表达式返回的不是 Unit 类型,则默认最后一行表达式的值类型就是返回值类型。

lambda 表达式语法:

  • lambda 表达式必须通过 {} 来包裹
  • 如果 lambda 声明了参数部分的类型,且返回值支持类型推导,则 lambda 表达式变量就可以省略函数类型声明
  • 如果 lambda 变量声明了函数类型,那么 lambda 表达式的参数部分的类型就可以省略
  • 如果 lambda 表达式返回的不是 Unit 类型,则默认最后一行表达式的值类型就是返回值类型。

函数 和 lambda表达式

fun 在没有等号、只有花括号的情况下,就是代码块函数体,如果返回值非 Unit,必须带 return

  • fun 在没有等号、只有花括号的情况下,就是代码块函数体,如果返回值非 Unit,必须带 return
fun foo(x: Int) {
    print(x)
}

fun foo(x: Int, y: Int): Int {
    return x + y
}

fun 带有等号,没有花括号,是单表达式函数体,可以省略 return

  • fun 带有等号,没有花括号,是单表达式函数体,可以省略 return
fun foo(x: Int, y: Int) = x + y

不管是用 val 还是 fun 声明,如果是等号加花括号的语法,就是声明一个 lambda 表达式。

  • 不管是用 val 还是 fun 声明,如果是等号加花括号的语法,就是声明一个 lambda 表达式。
val foo = { x: Int, y: Int ->
    x + y
}
// 调用方式: foo.invoke(1, 2) 或者 foo(1, 2)
fun foo(x: Int) = { y: Int ->
    x + y
}
// 调用方式: foo(1).invoke(2) 或者 foo(1)(2)

lambda 表达式自调用

  • lambda 表达式自调用
{x: Int, y: Int -> x + y}(1, 2)
————————

1、 Functions

Code block function body:

fun sum(x: Int, y: Int): Int {
    return x + y
}

Expression function body:

fun sum(x: Int, y: Int) = x + y

In general, the return value type can not be declared when using the expression function body. In some complex cases, such as recursion, the declared return value type must be displayed even if the expression function body is used.

Summary:
Function arguments must display declaration types
For the non expression function body, the function parameter must display the declaration type. The return value can be omitted except that the type is unit. In other cases, the return value must display the declaration type
If it is a recursive function, the declared parameters and return value types must be displayed
If it is a public method, for the readability of the code, try to display the declared function parameters and return value types

Summary:

  • Function arguments must display declaration types
  • For the non expression function body, the function parameter must display the declaration type. The return value can be omitted except that the type is unit. In other cases, the return value must display the declaration type
  • If it is a recursive function, the declared parameters and return value types must be displayed
  • If it is a public method, for the readability of the code, try to display the declared function parameters and return value types

2、 Function type

In kotlin, the format of function type is as follows:

() -> Unit

In kotlin, the function type declaration must follow the following points:

In kotlin, the function type declaration must follow the following points:

Via – & gt; Symbols to organize parameter types and return value types. On the left is the parameter type and on the right is the return value type
Parameter types must be wrapped in parentheses
Even if the return value type is unit, the declaration must be displayed.

  • Parameter types and return value types are organized by the – > symbol. On the left is the parameter type and on the right is the return value type
  • Parameter types must be wrapped in parentheses
  • Even if the return value type is unit, the declaration must be displayed.

Use to reference the method of a class, such as:

::
class A {
    fun test()
}

We can keep the reference to the test () method as follows

val a = A () // 创建类的对象
val f = a::test // 通过对象引用方法
f.invike() // 调用方法

三、lambda 表达式

val sum: (Int, Int) -> Int = {x: Int, y: Int -> x + y}

Since type derivation is supported, it can be simplified to

val sum: (Int, Int) -> Int = {x, y -> x + y}

Or:

val sum = {x: Int, y: Int -> x + y}

Lambda expression syntax:
Lambda expressions must be wrapped by {}
If lambda declares the type of the parameter part and the return value supports type derivation, the lambda expression variable can omit the function type declaration
If the lambda variable declares a function type, the type of the parameter part of the lambda expression can be omitted
If the lambda expression does not return the unit type, the value type of the last line of expression is the return value type by default.

Lambda expression syntax:

  • Lambda expressions must be wrapped by {}
  • If lambda declares the type of the parameter part and the return value supports type derivation, the lambda expression variable can omit the function type declaration
  • If the lambda variable declares a function type, the type of the parameter part of the lambda expression can be omitted
  • If the lambda expression does not return the unit type, the value type of the last line of expression is the return value type by default.

Functions and lambda expressions

When fun has no equal sign and only curly braces, it is the body of the code block function. If the return value is not unit, it must be returned

  • When fun has no equal sign and only curly braces, it is the body of the code block function. If the return value is not unit, it must be returned
fun foo(x: Int) {
    print(x)
}

fun foo(x: Int, y: Int): Int {
    return x + y
}

Fun is a single expression function with an equal sign and no curly braces. Return can be omitted

  • Fun is a single expression function with an equal sign and no curly braces. Return can be omitted
fun foo(x: Int, y: Int) = x + y

Whether it is declared with Val or fun, if it is the syntax of equal sign and curly braces, it is to declare a lambda expression.

  • Whether it is declared with Val or fun, if it is the syntax of equal sign and curly braces, it is to declare a lambda expression.
val foo = { x: Int, y: Int ->
    x + y
}
// 调用方式: foo.invoke(1, 2) 或者 foo(1, 2)
fun foo(x: Int) = { y: Int ->
    x + y
}
// 调用方式: foo(1).invoke(2) 或者 foo(1)(2)

Lambda expression self calling

  • Lambda expression self calling
{x: Int, y: Int -> x + y}(1, 2)