Kotlin - 函式

Kotlin 是一種靜態型別語言，因此，函式在其中扮演著重要的角色。我們對函式非常熟悉，因為我們在上一章的示例中一直在使用函式。函式是一段用於執行特定任務的程式碼塊。所有現代程式語言都支援函式，它們也被稱為方法或子程式。

從廣義上講，函式接收一些稱為引數的輸入，對這些輸入執行某些操作，最後返回一個值。

Kotlin 內建函式

Kotlin 提供了許多內建函式，我們在示例中使用了一些內建函式。例如，print() 和 println() 是我們最常用的內建函式，用於將輸出列印到螢幕上。

示例

fun main(args: Array<String>) {
   println("Hello, World!")
}

使用者定義函式

Kotlin 允許我們使用關鍵字fun建立自己的函式。使用者定義的函式接受一個或多個引數，執行操作，並將該操作的結果作為值返回。

語法

fun functionName(){  
   // body of function 
}  

定義函式後，我們可以在需要時呼叫它任意多次。以下是如何呼叫 Kotlin 函式的簡單語法

functionName()

示例

以下是如何定義和呼叫一個使用者定義函式的示例，該函式將列印簡單的“Hello, World！”

fun main(args: Array<String>) {

   printHello()
   
}

fun printHello(){
   println("Hello, World!")
}

執行以上 Kotlin 程式後，將生成以下輸出

Hello, World!

函式引數

使用者定義的函式可以接受零個或多個引數。引數是可選的，可以根據需要使用。例如，我們上面定義的函式沒有使用任何引數。

示例

以下是如何編寫一個使用者定義函式的示例，該函式將新增兩個給定的數字並列印它們的和

fun main(args: Array<String>) {
   val a = 10
   val b = 20
   
   printSum(a, b)
   
}

fun printSum(a:Int, b:Int){

   println(a + b)
}

執行以上 Kotlin 程式後，將生成以下輸出

30

返回值

Kotlin 函式根據需要返回一個值。同樣，返回一個值也是完全可選的。

要返回一個值，請使用return關鍵字，並在函式的括號後指定返回型別

示例

以下是如何編寫一個使用者定義函式的示例，該函式將新增兩個給定的數字並返回它們的和

fun main(args: Array<String>) {
   val a = 10
   val b = 20
   
   val result = sumTwo(a, b)
   println( result )
   
}

fun sumTwo(a:Int, b:Int):Int{
   val x = a + b
   
   return x
}

執行以上 Kotlin 程式後，將生成以下輸出

30

返回 Unit 的函式

如果函式不返回有用的值，則其返回型別為Unit。Unit 是一種只有一個值的型別，該值為Unit。

fun sumTwo(a:Int, b:Int):Unit{
   val x = a + b
   
   println( x )
}

Unit 返回型別宣告也是可選的。以上程式碼等價於

fun sumTwo(a:Int, b:Int){
   val x = a + b
   
   println( x )
}

Kotlin 遞迴函式

遞迴函式在許多場景中很有用，例如計算數字的階乘或生成斐波那契數列。Kotlin 支援遞迴，這意味著 Kotlin 函式可以呼叫自身。

語法

fun functionName(){  
   ...
   functionName()
   ...
}  

示例

以下是如何計算數字 10 的階乘的 Kotlin 程式

fun main(args: Array<String>) {
   val a = 4
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a:Int):Int{
   val result:Int
   
   if( a <= 1){
      result = a
   }else{
      result = a*factorial(a-1)
   }
   
   return result
}

執行以上 Kotlin 程式後，將生成以下輸出

24

Kotlin 尾遞迴

如果函式呼叫自身是其執行的最後一個操作，則遞迴函式有資格進行尾遞迴。

示例

以下是如何使用尾遞迴計算數字 10 的階乘的 Kotlin 程式。這裡我們需要確保乘法在遞迴呼叫之前完成，而不是之後。

fun main(args: Array<String>) {
   val a = 4
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a: Int, accum: Int = 1): Int {
    val result = a * accum
    return if (a <= 1) {
        result
    } else {
        factorial(a - 1, result)
    }
}

執行以上 Kotlin 程式後，將生成以下輸出

24

Kotlin 尾遞迴在計算階乘或對大數進行其他處理時很有用。因此，為了避免java.lang.StackOverflowError，必須使用尾遞迴。

高階函式

高階函式是指將另一個函式作為引數和/或返回一個函式的函式。

示例

以下是一個接受兩個整數引數 a 和 b 的函式，此外，它還接受另一個函式operation作為引數

fun main(args: Array<String>) {
   
   val result = calculate(4, 5, ::sum) 
   println( result )
   
}
fun sum(a: Int, b: Int) = a + b 

fun calculate(a: Int, b: Int, operation:(Int, Int) -> Int): Int {
    return operation(a, b)                                       
}

執行以上 Kotlin 程式後，將生成以下輸出

9

這裡我們呼叫高階函式，傳入兩個整數值和函式引數::sum。這裡::是 Kotlin 中按名稱引用函式的表示法。

示例

讓我們再看一個函式返回另一個函式的示例。這裡我們定義了一個返回函式的高階函式。這裡(Int) -> Int表示square函式的引數和返回型別。

fun main(args: Array<String>) { 
   val func = operation() 
   println( func(4) )
   
}
fun square(x: Int) = x * x

fun operation(): (Int) -> Int {
    return ::square                                       
}

執行以上 Kotlin 程式後，將生成以下輸出

9

Kotlin Lambda 函式

Kotlin lambda 是一個沒有名稱的函式，用花括號 {} 定義，它接受零個或多個引數以及函式體。

函式體寫在變數（如果有）後面，後跟 -> 運算子。

語法

{variable with type -> body of the function}  

示例

fun main(args: Array<String>) { 

   val upperCase = { str: String -> str.toUpperCase() }  

   println( upperCase("hello, world!") )
   
}                           

執行以上 Kotlin 程式後，將生成以下輸出

HELLO, WORLD!

Kotlin 行內函數

內聯函式用inline關鍵字宣告。使用行內函數可以提高高階函式的效能。行內函數告訴編譯器將引數和函式複製到呼叫站點。

示例

fun main(args: Array<String>) { 

   myFunction({println("Inline function parameter")})
   
}
inline fun myFunction(function:()-> Unit){
   println("I am inline function - A")

   function()
   
   println("I am inline function - B")
}                               

執行以上 Kotlin 程式後，將生成以下輸出

I am inline function - A
Inline function parameter
I am inline function - B

fun main(args: Array<String>) {
   val a = 100000
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a:Int):Int{
   val result:Int
   
   if( a <= 1){
      result = a
   }else{
      result = a*factorial(a-1)
   }
   
   return result
}