Skip to content

函数 ​

在 Kotlin 中,你可以使用 fun 关键字声明自己的函数。

kotlin
fun hello() {
    return println("Hello, world!")
}

fun main() {
    hello()
    // Hello, world!
}

在 Kotlin 中:

  • 函数形参写在圆括号 () 内。
  • 每个形参都必须指定类型,多个形参之间必须用逗号 , 分隔。
  • 返回值类型写在函数的圆括号 () 之后,用冒号 : 分隔。
  • 函数体写在花括号 {} 内。
  • return 关键字用于退出函数或从函数返回某个值。

如果函数不返回任何有用的内容,可以省略返回值类型和 return 关键字。更多相关内容请参阅无返回值的函数。

在以下示例中:

  • x 和 y 是函数形参。
  • x 和 y 的类型为 Int。
  • 该函数的返回值类型为 Int。
  • 调用该函数时,会返回 x 与 y 之和。
kotlin
fun sum(x: Int, y: Int): Int {
    return x + y
}

fun main() {
    println(sum(1, 2))
    // 3
}

我们在编码约定中建议,函数命名应以小写字母开头,并采用不带下划线的骆驼拼写法。

具名实参 ​

为了使代码更简洁,调用函数时不需要包含形参名称。不过,包含形参名称确实可以提高代码的可读性。这被称为使用具名实参。如果包含了形参名称,就可以按任意顺序书写实参。

在以下示例中,使用字符串模板($)访问形参的值,将其转换为 String 类型,然后串联为一个字符串进行输出。

kotlin
fun printMessageWithPrefix(message: String, prefix: String) {
    println("[$prefix] $message")
}

fun main() {
    // 使用具名实参并调换形参顺序
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

默认形参值 ​

你可以为函数形参定义默认值。在调用函数时,任何带有默认值的形参都可以省略。要声明默认值,请在类型之后使用赋值运算符 =:

kotlin
fun printMessageWithPrefix(message: String, prefix: String = "Info") {
    println("[$prefix] $message")
}

fun main() {
    // 同时传入两个实参调用函数
    printMessageWithPrefix("Hello", "Log") 
    // [Log] Hello
    
    // 仅传入 message 实参调用函数
    printMessageWithPrefix("Hello")        
    // [Info] Hello
    
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

你可以跳过带有默认值的特定形参,而无需省略所有形参。但是,在第一个被跳过的形参之后,必须为后续的所有实参指明名称。

无返回值的函数 ​

如果你的函数不返回有用的值,那么它的返回值类型就是 Unit。Unit 是一种只有一个值的类型——即 Unit。你无需在函数体中显式声明返回 Unit。这意味着你不需要使用 return 关键字或声明返回值类型:

kotlin
fun printMessage(message: String) {
    println(message)
    // `return Unit` 或 `return` 是可选的
}

fun main() {
    printMessage("Hello")
    // Hello
}

单表达式函数 ​

为了让代码更简洁,你可以使用单表达式函数。例如,sum() 函数可以简写为:

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

fun main() {
    println(sum(1, 2))
    // 3
}

你可以移除花括号 {},并使用赋值运算符 = 来声明函数体。当你使用赋值运算符 = 时,Kotlin 会使用类型推断,因此你也可以省略返回值类型。这样 sum() 函数就变成了一行:

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

fun main() {
    println(sum(1, 2))
    // 3
}

但是,如果你希望其他开发者能够快速理解你的代码,即使使用赋值运算符 =,显式定义返回值类型也是一个好习惯。

如果使用 {} 花括号来声明函数体,则必须声明返回值类型,除非它是 Unit 类型。

函数中的提前返回 ​

如果想在某一点阻止函数中的代码继续执行,可以使用 return 关键字。此示例使用 if 在条件表达式为真时提前从函数返回:

kotlin
// 已注册用户名的列表
val registeredUsernames = mutableListOf("john_doe", "jane_smith")

// 已注册电子邮箱的列表
val registeredEmails = mutableListOf("john@example.com", "jane@example.com")

fun registerUser(username: String, email: String): String {
    // 如果用户名已被占用,则提前返回
    if (username in registeredUsernames) {
        return "Username already taken. Please choose a different username."
    }

    // 如果电子邮箱已被注册,则提前返回
    if (email in registeredEmails) {
        return "Email already registered. Please use a different email."
    }

    // 如果用户名和电子邮箱均未被占用,则继续注册
    registeredUsernames.add(username)
    registeredEmails.add(email)

    return "User registered successfully: $username"
}

fun main() {
    println(registerUser("john_doe", "newjohn@example.com"))
    // Username already taken. Please choose a different username.
    println(registerUser("new_user", "newuser@example.com"))
    // User registered successfully: new_user
}

练习:函数 ​

计算圆的面积

编写一个名为 circleArea 的函数,该函数接收以整数格式表示的圆半径作为形参,并输出该圆的面积。

在本练习中,你将导入一个软件包,以便可以通过 PI 访问 的值。有关导入软件包的更多信息,请参阅软件包和导入。

提示
计算圆面积的公式为 ,其中 为半径。
kotlin
import kotlin.math.PI

// 在此处编写你的代码

fun main() {
    println(circleArea(2))
}
示例解决方案 {...}
kotlin
import kotlin.math.PI

fun circleArea(radius: Int): Double {
    return PI * radius * radius
}

fun main() {
    println(circleArea(2)) // 12.566370614359172
}
将函数重写为单表达式

将上一练习中的 circleArea 函数重写为单表达式函数。

kotlin
import kotlin.math.PI

// 在此处编写你的代码

fun main() {
    println(circleArea(2))
}
示例解决方案 {...}
kotlin
import kotlin.math.PI

fun circleArea(radius: Int): Double = PI * radius * radius

fun main() {
    println(circleArea(2)) // 12.566370614359172
}
使用默认形参和具名实参重构函数

你有一个将以小时、分钟和秒给出的时间间隔转换为秒的函数。在大多数情况下,你只需要传递一到两个函数形参,其余形参都等于 0。通过使用默认形参值和具名实参来改进该函数及调用它的代码,使代码更易读。

kotlin
// 重构此函数:为 hours、minutes 和 seconds 提供默认值 0
fun intervalInSeconds(hours: Int, minutes: Int, seconds: Int) =
    ((hours * 60) + minutes) * 60 + seconds

fun main() {
    // 尽可能使用具名实参简化这些调用
    println(intervalInSeconds(1, 20, 15))
    println(intervalInSeconds(0, 1, 25))
    println(intervalInSeconds(2, 0, 0))
    println(intervalInSeconds(0, 10, 0))
    println(intervalInSeconds(1, 0, 1))
}
示例解决方案 {...}
kotlin
fun intervalInSeconds(hours: Int = 0, minutes: Int = 0, seconds: Int = 0) =
    ((hours * 60) + minutes) * 60 + seconds

fun main() {
    println(intervalInSeconds(1, 20, 15))
    println(intervalInSeconds(minutes = 1, seconds = 25))
    println(intervalInSeconds(hours = 2))
    println(intervalInSeconds(minutes = 10))
    println(intervalInSeconds(hours = 1, seconds = 1))
}

Lambda 表达式 ​

Kotlin 允许你通过使用 lambda 表达式来编写更加简洁的函数代码。

例如,以下 uppercaseString() 函数:

kotlin
fun uppercaseString(text: String): String {
    return text.uppercase()
}
fun main() {
    println(uppercaseString("hello"))
    // HELLO
}

也可以写成 lambda 表达式:

kotlin
fun main() {
    val upperCaseString = { text: String -> text.uppercase() }
    println(upperCaseString("hello"))
    // HELLO
}

Lambda 表达式初看可能难以理解,因此让我们来分解一下。Lambda 表达式写在花括号 {} 内。

在 lambda 表达式内部,需要书写:

  • 形参后跟 ->。
  • -> 之后为函数体。

在上一个示例中:

  • text 是函数形参。
  • text 的类型为 String。
  • 该函数返回在 text 上调用 .uppercase() 函数的结果。
  • 整个 lambda 表达式通过赋值运算符 = 赋值给 upperCaseString 变量。
  • 通过像使用函数一样使用变量 upperCaseString 并传入字符串 "hello" 作为实参来调用该 lambda 表达式。
  • println() 函数输出结果。

如果声明不带形参的 lambda 表达式,则无需使用 ->。例如:

kotlin
{ println("Log message") }

Lambda 表达式可以用于多种场景。你可以:

传递给另一个函数 ​

将 lambda 表达式传递给函数的一个典型实用场景,是对集合使用 .filter() 函数:

kotlin
fun main() {
    val numbers = listOf(1, -2, 3, -4, 5, -6)
    
    val positives = numbers.filter ({ x -> x > 0 })
    
    val isNegative = { x: Int -> x < 0 }
    val negatives = numbers.filter(isNegative)
    
    println(positives)
    // [1, 3, 5]
    println(negatives)
    // [-2, -4, -6]
}

.filter() 函数接受一个 lambda 表达式作为谓词,并将其应用于列表中的每个元素。只有当谓词返回 true 时,该函数才会保留该元素:

  • 如果元素为正数,{ x -> x > 0 } 返回 true。
  • 如果元素为负数,{ x -> x < 0 } 返回 true。

此示例演示了将 lambda 表达式传递给函数的两种方式:

  • 对于正数,该示例直接在 .filter() 函数中添加 lambda 表达式。
  • 对于负数,该示例将 lambda 表达式赋值给 isNegative 变量。然后将 isNegative 变量用作 .filter() 函数的实参。在这种情况下,必须在 lambda 表达式中指定函数形参(x)的类型。

如果 lambda 表达式是唯一的函数形参,可以省略函数的圆括号 ():

kotlin
val positives = numbers.filter { x -> x > 0 }

这是尾随 lambda 的一个示例,本章末尾将对此进行更详细的讨论。

另一个很好的示例是使用 .map() 函数转换集合中的元素:

kotlin
fun main() {
    val numbers = listOf(1, -2, 3, -4, 5, -6)
    val doubled = numbers.map { x -> x * 2 }
    
    val isTripled = { x: Int -> x * 3 }
    val tripled = numbers.map(isTripled)
    
    println(doubled)
    // [2, -4, 6, -8, 10, -12]
    println(tripled)
    // [3, -6, 9, -12, 15, -18]
}

.map() 函数接受一个 lambda 表达式作为转换函数:

  • { x -> x * 2 } 获取列表中的每个元素,并返回该元素乘以 2 的结果。
  • { x -> x * 3 } 获取列表中的每个元素,并返回该元素乘以 3 的结果。

函数类型 ​

在从函数返回 lambda 表达式之前,首先需要了解函数类型。

你已经了解了基本类型,但函数本身也是有类型的。Kotlin 的类型推断可以根据形参类型推断出函数的类型。但在某些情况下,你可能需要显式指定函数类型。编译器需要函数类型以便了解该函数允许和不允许的操作。

函数类型的语法如下:

  • 每个形参的类型写在圆括号 () 内,并用逗号 , 分隔。
  • 返回值类型写在 -> 之后。

例如:(String) -> String 或 (Int, Int) -> Int。

如果为 upperCaseString() 定义了函数类型,lambda 表达式将如下所示:

kotlin
val upperCaseString: (String) -> String = { text -> text.uppercase() }

fun main() {
    println(upperCaseString("hello"))
    // HELLO
}

如果你的 lambda 表达式没有形参,则圆括号 () 为空。例如:() -> Unit

必须在 lambda 表达式中或作为函数类型声明形参和返回值类型。否则,编译器将无法得知 lambda 表达式的类型。

例如,以下代码将无法正常运行:

val upperCaseString = { str -> str.uppercase() }

从函数返回 ​

可以从函数返回 lambda 表达式。为了让编译器理解返回的 lambda 表达式是什么类型,必须声明函数类型。

在以下示例中,toSeconds() 函数的函数类型为 (Int) -> Int,因为它总是返回一个接受 Int 类型形参并返回 Int 值的 lambda 表达式。

此示例使用 when 表达式来确定调用 toSeconds() 时返回哪个 lambda 表达式:

kotlin
fun toSeconds(time: String): (Int) -> Int = when (time) {
    "hour" -> { value -> value * 60 * 60 }
    "minute" -> { value -> value * 60 }
    "second" -> { value -> value }
    else -> { value -> value }
}

fun main() {
    val timesInMinutes = listOf(2, 10, 15, 1)
    val min2sec = toSeconds("minute")
    val totalTimeInSeconds = timesInMinutes.map(min2sec).sum()
    println("Total time is $totalTimeInSeconds secs")
    // Total time is 1680 secs
}

单独调用 ​

通过在花括号 {} 后添加圆括号 (),并将所有实参放入圆括号内,可以单独调用 lambda 表达式:

kotlin
fun main() {
    println({ text: String -> text.uppercase() }("hello"))
    // HELLO
}

尾随 lambda ​

正如前面所见,如果 lambda 表达式是唯一的函数形参,可以省略函数的圆括号 ()。如果 lambda 表达式作为函数的最后一个形参传递,那么该表达式可以写在函数圆括号 () 之外。在这两种情况下,这种语法都称为尾随 lambda。

例如,.fold() 函数接受一个初始值和一个操作:

kotlin
fun main() {
    // 初始值为 0。
    // 该操作将初始值与列表中的每个项累加求和。
    println(listOf(1, 2, 3).fold(0, { x, item -> x + item })) // 6

    // 或者,采用尾随 lambda 的形式
    println(listOf(1, 2, 3).fold(0) { x, item -> x + item })  // 6
}

有关 lambda 表达式的更多信息,请参阅 Lambda 表达式和匿名函数。

我们教程的下一步是学习 Kotlin 中的类。

练习:Lambda 表达式 ​

使用 lambda 表达式构建 URL 列表

你有一个 Web 服务支持的操作列表、所有请求的通用前缀,以及一个特定资源的 ID。 若要对 ID 为 5 的资源请求 title 操作,需要创建以下 URL:https://example.com/book-info/5/title。 使用 lambda 表达式从操作列表中创建 URL 列表。

kotlin
fun buildUrls(actions: List<String>, prefix: String, id: Int): List<String> {
    return TODO() // 在此处编写你的代码
}

fun main() {
    val actions = listOf("title", "year", "author")
    val urls = buildUrls(actions, "https://example.com/book-info", 5)
    println(urls)
}
示例解决方案 {...}
kotlin
fun buildUrls(actions: List<String>, prefix: String, id: Int): List<String> {
    return actions.map { action -> "$prefix/$id/$action" }
}

fun main() {
    val actions = listOf("title", "year", "author")
    val urls = buildUrls(actions, "https://example.com/book-info", 5)
    println(urls)
}
多次重复执行操作

编写一个接收 Int 值和一个操作(类型为 () -> Unit 的函数)的函数,该函数将该操作重复执行指定的次数。然后使用此函数输出 5 次“Hello”。

kotlin
fun repeatN(n: Int, action: () -> Unit) {
    // 在此处编写你的代码
}

fun main() {
    // 在此处编写你的代码
}
示例解决方案 {...}
kotlin
fun repeatN(n: Int, action: () -> Unit) {
    for (i in 1..n) {
        action()
    }
}

fun main() {
    repeatN(5) {
        println("Hello")
    }
}