中国做的好的房产网站营销推广外包公司

想要声明一个函数需要使用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] HelloprintMessageWithPrefix("Hello")        // [Info] HelloprintMessageWithPrefix(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 + yfun 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函数放在()外