Kotlin 函数基础 #

fun functionName(param1: Type1, param2: Type2): ReturnType {
    // 函数体
    return result
}

fun greet() {
    println("Hello, Kotlin!")
}

// 调用
greet()

fun greet(name: String) {
    println("Hello, $name!")
}

greet("Kotlin")  // Hello, Kotlin!

fun add(a: Int, b: Int): Int {
    return a + b
}

val sum = add(10, 20)  // 30

// 完整形式
fun add(a: Int, b: Int): Int {
    return a + b
}

// 表达式体形式
fun add(a: Int, b: Int): Int = a + b

// 类型推断
fun add(a: Int, b: Int) = a + b

fun createPerson(name: String, age: Int, city: String) {
    println("$name, $age years old, lives in $city")
}

createPerson("Kotlin", 10, "Beijing")

createPerson(
    name = "Kotlin",
    age = 10,
    city = "Beijing"
)

// 顺序可以改变
createPerson(
    city = "Beijing",
    name = "Kotlin",
    age = 10
)

fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

greet("Kotlin")              // Hello, Kotlin!
greet("Kotlin", "Hi")        // Hi, Kotlin!
greet(name = "Kotlin", greeting = "Welcome")  // Welcome, Kotlin!

fun createUser(
    name: String,
    age: Int = 0,
    email: String = "",
    isActive: Boolean = true
) {
    println("User: $name, $age, $email, $isActive")
}

// 只指定部分参数
createUser("Kotlin")
createUser("Kotlin", email = "kotlin@example.com")
createUser("Kotlin", isActive = false, age = 10)

fun sum(vararg numbers: Int): Int {
    return numbers.sum()
}

sum(1, 2, 3, 4, 5)  // 15
sum()               // 0

fun format(prefix: String, vararg items: String, suffix: String): String {
    return "$prefix ${items.joinToString()} $suffix"
}

format("Start:", "A", "B", "C", suffix = "End")
// Start: A, B, C End

val numbers = intArrayOf(1, 2, 3)
sum(*numbers)  // 6

val list = arrayOf("A", "B", "C")
format("Start:", *list, suffix = "End")

fun printMessage(message: String): Unit {
    println(message)
}

// Unit 可以省略
fun printMessage(message: String) {
    println(message)
}

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun infiniteLoop(): Nothing {
    while (true) {
        // 无限循环
    }
}

fun findUser(id: Int): User? {
    return if (id > 0) User(id) else null
}

fun outerFunction(x: Int): Int {
    fun innerFunction(y: Int): Int {
        return x + y  // 可以访问外部变量
    }
    
    return innerFunction(10)
}

fun validateUser(user: User): Boolean {
    fun validateName(name: String): Boolean {
        return name.isNotBlank() && name.length <= 50
    }
    
    fun validateAge(age: Int): Boolean {
        return age in 0..150
    }
    
    return validateName(user.name) && validateAge(user.age)
}

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n <= 1) acc else factorial(n - 1, n * acc)
}

factorial(5)  // 120

// 正确：尾递归
tailrec fun sum(n: Int, acc: Int = 0): Int {
    return if (n <= 0) acc else sum(n - 1, acc + n)
}

// 错误：不是尾递归（递归调用后还有操作）
// tailrec fun factorial(n: Int): Int {
//     return if (n <= 1) 1 else n * factorial(n - 1)
// }

fun add(a: Int, b: Int): Int = a + b
fun add(a: Double, b: Double): Double = a + b
fun add(a: Int, b: Int, c: Int): Int = a + b + c

// 使用重载
fun greet(name: String) = greet(name, "Hello")
fun greet(name: String, greeting: String) {
    println("$greeting, $name!")
}

// 使用默认参数（推荐）
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

class Point(val x: Int, val y: Int) {
    infix fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

val p1 = Point(1, 2)
val p2 = Point(3, 4)

// 中缀调用
val p3 = p1 plus p2

// 普通调用
val p4 = p1.plus(p2)

// until
1 until 10

// in
x in list

// to（创建 Pair）
"key" to "value"

// step
1..10 step 2

// 函数类型
val add: (Int, Int) -> Int = { a, b -> a + b }

// 带接收者的函数类型
val greet: String.() -> String = { "Hello, $this" }

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

operate(10, 5) { x, y -> x + y }  // 15
operate(10, 5) { x, y -> x * y }  // 50

fun getOperation(symbol: String): (Int, Int) -> Int {
    return when (symbol) {
        "+" -> { a, b -> a + b }
        "-" -> { a, b -> a - b }
        "*" -> { a, b -> a * b }
        "/" -> { a, b -> a / b }
        else -> { _, _ -> 0 }
    }
}

val add = getOperation("+")
add(10, 5)  // 15

fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

fun String.truncate(maxLength: Int): String {
    return if (length <= maxLength) this else take(maxLength) + "..."
}

// 使用
"test@example.com".isEmail()  // true
"Hello World".truncate(5)     // "Hello..."

fun buildString(builderAction: StringBuilder.() -> Unit): String {
    val sb = StringBuilder()
    sb.builderAction()
    return sb.toString()
}

val result = buildString {
    append("Hello")
    append(", ")
    append("Kotlin")
}
// "Hello, Kotlin"

data class ServerConfig(
    var host: String = "localhost",
    var port: Int = 8080,
    var ssl: Boolean = false
)

fun server(config: ServerConfig.() -> Unit): ServerConfig {
    return ServerConfig().apply(config)
}

val config = server {
    host = "example.com"
    port = 443
    ssl = true
}

// 推荐：动词开头
fun calculateTotal() { }
fun findUser() { }
fun validateInput() { }

// 布尔返回值用 is/has/can
fun isValid(): Boolean { }
fun hasPermission(): Boolean { }
fun canExecute(): Boolean { }

// 推荐：函数应该短小精悍
fun process(data: String): Result {
    val validated = validate(data)
    val transformed = transform(validated)
    return save(transformed)
}

// 不推荐：过长的函数
fun processAll(data: String): Result {
    // 100 行代码...
}

// 不推荐：参数过多
fun createUser(name: String, age: Int, email: String, 
               phone: String, address: String, city: String) { }

// 推荐：使用数据类
data class UserParams(
    val name: String,
    val age: Int,
    val email: String,
    val phone: String = "",
    val address: String = "",
    val city: String = ""
)

fun createUser(params: UserParams) { }