4：kotlin 方法（Functions）

想要声明一个函数需要使用fun关键字

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

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

格式:

fun 方法名(参数1: 参数1类型, 参数2 : 参数2类型, ...): 返回值类型 {
    方法体
    return 返回值
}

fun 方法名(参数1: 参数1类型, 参数2 : 参数2类型, ...){
    方法体
}

参数可以有一个或者多个，也可以没有参数。

举例

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

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

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

fun main() {
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

建议使用小驼峰命名法

默认参数值

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
}

如果跳过某一个参数，若果有后续的参数，必须指定参数名字

单一表达式方法

fun sum(x: Int, y: Int): Int {
    return x + y
}
fun main() {
    println(sum(1, 2))
    // 3
}

对单表达式函数，可以进行一下简化

• 去除返回值类型
• 去除return关键字
• 去除{}
• 用=连接方法体

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

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

Lambda 表达式

如下方法

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

可写为

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

• 方法定义在{}内
• 参数后边跟着->
• ->后边跟着方法体
• str是参数名字
• String是参数类型
• 返回值为.uppercase()方法的返回值类型

固定格式，没什么可研究的

如果是无参数的Lambda方法

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

Lambda表达式可以以多种方式使用

• 将lambda分配给稍后可以调用的变量
• 将lambda表达式作为参数传递给另一个函数
• 从函数返回lambda表达式
• 单独调用lambda表达式

赋值给变量

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

函数类型

对于使用变量接收一个Lambda函数时，可能需要对函数进行类型定义

• 参数类型写在()内，多个类型用,分割
• 返回值类型跟在->后边

val upperCaseString1: (String) -> String = { string -> string.uppercase() }
// 					     ↑          ↑
//                    参数类型   返回值类型		
val upperCaseString2 : () -> String = { "hello" }

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

作为参数使用

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

.fileter()方法接收一个Lambda方法作为参数

• { x -> x > 0 } 获取List中>0的元素
• { x -> x < 0 } 获取List中<0的元素

作为返回值在方法中返回

fun main() {
    fun toSeconds(time: String): (Int) -> Int = when (time) {
//                      ↑          ↑       ↑
//          toSeconds的参数及类型   ↑  要返回的lambda函数的返回值类型   
//                        要返回的lambda函数的参数类型        
        "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
    }
}

Trailing lambdas （后置Lambda）

.fold()方法接收一个Int和一个lambda函数，调用方法时可写做

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函数放在()外