函式

您可以在 Kotlin 中使用 fun 關鍵字來宣告您自己的函式。

kotlin

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

fun main() {
    hello()
    // 哈囉，世界！
}

在 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
}

我們在程式碼慣例中建議函式名稱以小寫字母開頭，並使用駝峰式命名法 (camel case)，不使用底線。

具名引數

為了讓程式碼更簡潔，當呼叫函式時，您不必包含參數名稱。然而，包含參數名稱確實能讓您的程式碼更容易閱讀。這稱為使用具名引數。如果您包含參數名稱，則可以以任何順序撰寫參數。

在以下範例中，字串模板用於存取參數值，將它們轉換為 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
    
    // 僅呼叫帶有訊息參數的函式
    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("[email protected]", "[email protected]")

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", "[email protected]"))
    // 使用者名稱已被佔用。請選擇不同的使用者名稱。
    println(registerUser("new_user", "[email protected]"))
    // 使用者註冊成功：new_user
}

函式練習

練習 1

編寫一個名為 circleArea 的函式，該函式以整數格式的圓半徑作為參數，並輸出該圓的面積。

TIP

在此練習中，您會匯入一個套件，以便透過 PI 存取圓周率的值。有關匯入套件的更多資訊，請參閱套件和匯入。

提示

計算圓面積的公式是

πr^2

，其中

r

是半徑。

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
}

練習 2

將上一個練習中的 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
}

練習 3

您有一個函式，它將以小時、分鐘和秒為單位的時間間隔轉換為秒。在大多數情況下，您只需要傳遞一個或兩個函式參數，其餘參數都等於 0。請使用預設參數值和具名引數來改進此函式以及呼叫它的程式碼，以便程式碼更容易閱讀。

kotlin

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 表達式傳遞給函式的一個很好的範例，是在集合上使用 .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，因為它總是回傳一個 lambda 表達式，該表達式接受 Int 型別的參數並回傳一個 Int 值。

此範例使用 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")
    // 總時間為 1680 秒
}

獨立呼叫

Lambda 表達式可以透過在花括號 {} 後面加上圓括號 ()，並將任何參數包含在圓括號內來獨立呼叫：

kotlin

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

尾隨 lambda

如您所見，如果 lambda 表達式是唯一的函式參數，您可以省略函式圓括號 ()。如果 lambda 表達式作為函式的最後一個參數傳遞，則該表達式可以寫在函式圓括號 () 的外面。在這兩種情況下，這種語法都稱為尾隨 lambda。

例如，.fold() 函式接受一個初始值和一個操作：

kotlin

fun main() {
    // 初始值為零。
    // 該操作將初始值與列表中的每個項目累計求和。
    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 表達式練習

練習 1

您有一個網頁服務支援的動作列表、所有請求的共同前綴，以及特定資源的 ID。若要透過 ID 為 5 的資源請求動作 title，您需要建立以下 URL：https://example.com/book-info/5/title。請使用 lambda 表達式從動作列表中建立 URL 列表。

kotlin

fun main() {
    val actions = listOf("title", "year", "author")
    val prefix = "https://example.com/book-info"
    val id = 5
    val urls = // 在此編寫您的程式碼
    println(urls)
}

範例解答

kotlin

fun main() {
    val actions = listOf("title", "year", "author")
    val prefix = "https://example.com/book-info"
    val id = 5
    val urls = actions.map { action -> "$prefix/$id/$action" }
    println(urls)
}

練習 2

編寫一個函式，它接受一個 Int 值和一個動作（型別為 () -> Unit 的函式），然後重複執行該動作指定的次數。然後使用此函式印出「Hello」5 次。

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")
    }
}

基本類型

建構器

Spring

使用 Spring Boot 建立一個包含資料庫的 RESTful Web 服務

Java 遷移至 Kotlin 指南

C 互通

Objective-C 互通

記憶體管理器

參考與提示

用於 JS 平台的 Kotlin

概覽

執行 Dokka

輸出格式

最小化心智複雜度

函式

具名引數

預設參數值

沒有回傳值的函式

單一表達式函式

函式中的提前回傳

函式練習

傳遞給另一個函式

函式型別

從函式中回傳

獨立呼叫

尾隨 lambda

Lambda 表達式練習

使用 Spring Boot 建立一個包含資料庫的 RESTful Web 服務

函式 ​

具名引數 ​

預設參數值 ​

沒有回傳值的函式 ​

單一表達式函式 ​

函式中的提前回傳 ​

函式練習 ​

傳遞給另一個函式 ​

函式型別 ​

從函式中回傳 ​

獨立呼叫 ​

尾隨 lambda ​

Lambda 表達式練習 ​

函式

具名引數

預設參數值

沒有回傳值的函式

單一表達式函式

函式中的提前回傳

函式練習

傳遞給另一個函式

函式型別

從函式中回傳

獨立呼叫

尾隨 lambda

Lambda 表達式練習