Kotlin vs Swift：现代移动开发的“双子星”全面对比

// Kotlin
val immutable: String = "不可变"           // 常量（不可重新赋值）
var mutable: Int = 42                     // 变量
lateinit var lateVariable: String         // 延迟初始化（仅适用于 var，且必须是非空类型）

// Swift
let immutable: String = "不可变"           // 常量
var mutable: Int = 42                     // 变量
lazy var lazyVariable: String = { return "懒加载" }() // 懒加载（首次访问时初始化）

// Kotlin
fun greet(name: String): String {
    return "Hello, $name"
}

// 单表达式函数
fun square(x: Int) = x * x

// 扩展函数 —— 为现有类添加新方法
fun String.addExclamation() = this + "!"

// Swift
func greet(name: String) -> String {
    return "Hello, \(name)"
}

// 单表达式函数（Swift 5.1+）
func square(x: Int) -> Int { x * x }

// 扩展方法
extension String {
    func addExclamation() -> String {
        return self + "!"
    }
}

var nullable: String? = null              // 可空类型
var nonNullable: String = "不能为null"     // 非空类型

// 安全调用
val length = nullable?.length

// Elvis 操作符（提供默认值）
val result = nullable?.length ?: 0

// 非空断言（强制假设非空，可能崩溃）
val forced = nullable!!.length

// 安全转换
val str: String? = "hello"
val upper = str?.uppercase()

var optional: String? = nil               // 可选类型（Optional）
var nonOptional: String = "不能为nil"      // 非可选类型

// 可选绑定（Optional Binding）
if let unwrapped = optional {
    print(unwrapped.count)
}

// 空合并运算符（Nil Coalescing）
let result = optional?.count ?? 0

// 强制解包（Force Unwrapping）
let forced = optional!.count

// Guard 语句 —— 提早退出，提升代码可读性
guard let value = optional else { 
    return 
}
print(value) // 此处 value 已确定存在

// Kotlin
open class Animal(val name: String) {     // open 表示可被继承
    open fun makeSound() {
        println("Some sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("Woof!")
    }
}

// 数据类（自动生成 equals, hashCode, toString, copy 等）
data class Owner(val name: String, val age: Int)

// Swift
class Animal {
    let name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("Some sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

// 结构体（值类型）—— Swift 推荐优先使用 struct
struct Owner {
    let name: String
    let age: Int
}

// Kotlin
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }                    // [2, 4, 6, 8, 10]
val even = numbers.filter { it % 2 == 0 }               // [2, 4]
val sum = numbers.reduce { acc, num -> acc + num }      // 15

// Swift
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }                    // [2, 4, 6, 8, 10]
let even = numbers.filter { $0 % 2 == 0 }               // [2, 4]
let sum = numbers.reduce(0, +)                          // 15

// 声明挂起函数
suspend fun fetchData(): String {
    delay(1000) // 模拟异步等待
    return "Data"
}

// 使用协程（如在 Android ViewModel 中）
viewModelScope.launch {
    val data = fetchData()
    // 更新 UI（自动在主线程恢复）
}

// 异步函数
func fetchData() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "Data"
}

// 使用 async/await
Task {
    let data = await fetchData()
    // 更新 UI
}

// 共享逻辑层
expect fun platformName(): String

class Greeting {
    fun greet(): String = "Hello from ${platformName()}"
}

// Android 实现
actual fun platformName(): String = "Android"

// iOS 实现（通过 Kotlin/Native 编译为 Framework）
actual fun platformName(): String = "iOS"

#if os(iOS)
import UIKit
#elseif os(macOS)
import AppKit
#endif

func getPlatform() -> String {
    #if os(iOS)
    return "iOS"
    #elseif os(macOS)
    return "macOS"
    #else
    return "Unknown"
    #endif
}