Kotlin vs Dart vs Swift：语法对比全解

我来从多个维度对比 Kotlin、Dart 和 Swift 这三种现代编程语言的语法：

一、基础语法对比

1. 变量声明

// Kotlin
val immutable = "不可变"  // 只读变量
var mutable = "可变"      // 可变变量
lateinit var late: String // 延迟初始化

// Dart
final immutable = '不可变'; // 运行时常量
const compileConst = '编译时常量'; // 编译时常量
var mutable = '可变'; // 类型推断
String explicit = '显式类型'; // 显式类型
late String lateVar; // 延迟初始化

// Swift
let constant = "不可变"      // 常量
var variable = "可变"        // 变量
lazy var lazyVar: String = { // 延迟初始化
    return "lazy"
}()

2. 空安全

// Kotlin
var nullable: String? = null // 可空类型
val length = nullable?.length ?: 0 // 安全调用和 Elvis 操作符
val forced = nullable!!.length // 非空断言

// Dart
String? nullable = null; // 可空类型（Dart 2.12+）
int length = nullable?.length ?? 0; // 空感知和空合并
int forced = nullable!.length; // 空断言

// Swift
var optional: String? = nil // 可选类型
let length = optional?.count ?? 0 // 可选链和空合并
let forced = optional!.count // 强制解包

三、函数/方法

1. 基本定义

// Kotlin - 函数式风格
fun add(a: Int, b: Int): Int = a + b // 单表达式函数
fun process(name: String = "default") { // 默认参数
    println(name)
}

// Dart
int add(int a, int b) => a + b; // 箭头函数
void process({String name = 'default'}) { // 命名参数
    print(name);
}

// Swift
func add(_ a: Int, _ b: Int) -> Int { a + b } // 隐式返回（Swift 5.1+）
func process(name: String = "default") { // 默认参数
    print(name)
}

2. 高阶函数

// Kotlin
val numbers = listOf(1, 2, 3)
val doubled = numbers.map { it * 2 } // lambda 表达式
numbers.filter { it > 1 }
       .forEach { println(it) }

// Dart
var numbers = [1, 2, 3];
var doubled = numbers.map((e) => e * 2); // 箭头函数
numbers.where((e) => e > 1)
      .forEach(print);

// Swift
let numbers = [1, 2, 3]
let doubled = numbers.map { $0 * 2 } // 闭包表达式
numbers.filter { $0 > 1 }
      .forEach { print($0) }

四、类与对象

1. 类定义

// Kotlin - 简洁语法
class Person(
    val name: String, // 主构造函数参数
    var age: Int
) {
    init {
        println("初始化") // 初始化块
    }
    
    fun greet() = "Hello, $name"
}

// Dart
class Person {
  final String name;
  int age;
  
  Person(this.name, this.age); // 简洁构造函数
  
  String greet() => 'Hello, $name';
}

// Swift
class Person {
    let name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func greet() -> String {
        return "Hello, \(name)"
    }
}

2. 继承

// Kotlin - 默认 final
open class Animal(val name: String) // 必须用 open
class Dog(name: String) : Animal(name) {
    override fun sound() = "Woof!" // 必须显式 override
}

// Dart
class Animal {
  final String name;
  Animal(this.name);
  
  void sound() => print('Sound');
}

class Dog extends Animal {
  Dog(String name) : super(name);
  
  @override
  void sound() => print('Woof!');
}

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

class Dog: Animal {
    override func sound() { // 必须显式 override
        print("Woof!")
    }
}

五、异步编程

1. 异步语法

// Kotlin - 协程
suspend fun fetchData(): String {
    delay(1000)
    return "Data"
}

// 使用
viewModelScope.launch {
    val data = fetchData()
    updateUI(data)
}

// Dart - async/await
Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 1));
  return 'Data';
}

// 使用
fetchData().then((data) {
  updateUI(data);
});

// Swift - async/await
func fetchData() async -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000)
    return "Data"
}

// 使用
Task {
    let data = await fetchData()
    updateUI(data)
}

六、集合操作

1. 集合创建

// Kotlin
val list = listOf(1, 2, 3) // 不可变列表
val mutableList = mutableListOf(1, 2, 3) // 可变列表
val map = mapOf("a" to 1, "b" to 2)

// Dart
final list = [1, 2, 3]; // 列表字面量
final constList = const [1, 2, 3]; // 编译时常量
final map = {'a': 1, 'b': 2};

// Swift
let array = [1, 2, 3] // 数组
let dict = ["a": 1, "b": 2] // 字典
var mutableArray = [1, 2, 3] // 可变数组（使用 var）

七、扩展功能

1. 扩展函数/方法

// Kotlin
fun String.addExclamation(): String = "$this!"
"Hello".addExclamation() // "Hello!"

// Dart
extension StringExtension on String {
  String addExclamation() => '$this!';
}
"Hello".addExclamation(); // "Hello!"

// Swift
extension String {
    func addExclamation() -> String {
        return self + "!"
    }
}
"Hello".addExclamation() // "Hello!"

八、特性对比表

特性 Kotlin Dart Swift

空安全 ✅ 编译时 ✅ 健全空安全 ✅ 可选类型

类型推断 ✅ 强大 ✅ 良好 ✅ 强大

函数式编程 ✅ 优秀 ✅ 良好 ✅ 良好

协程/异步 ✅ 协程 ✅ async/await ✅ async/await

扩展函数 ✅ 支持 ✅ 支持 ✅ 支持

主平台 Android、JVM Flutter、Web iOS/macOS

语法简洁度 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐⭐

互操作性 Java JavaScript Objective-C

九、总结

1. Kotlin - 最函数式，语法最简洁，适合 Android 和 JVM 开发
2. Dart - 平衡性最好，Flutter 生态成熟，适合跨平台
3. Swift - 性能优秀，Apple 生态完善，语法现代但稍显冗长

三者都是现代、安全的语言，选择主要取决于：

· Android 开发 → Kotlin

· 跨平台移动开发 → Dart (Flutter)

· iOS/macOS 开发 → Swift

· 服务端/通用 → Kotlin 或 Dart