吃透 Swift 的 `@autoclosure`：把“表达式”变“闭包”的延迟利器

什么是 @autoclosure？

一句话：把"传入的表达式"自动包成"无参闭包"，实现延迟求值（lazy evaluation）。

语法糖级别：调用方完全无感，只需像传普通值一样写表达式；函数内部拿到的是 () -> T 闭包，想执行才执行。

为什么需要延迟求值？

反例：生产环境也强制计算

class Logger {
    static func log(_ message: String) {
        #if DEBUG
        print(message)
        #endif
    }
}

class DataSource {
    var data: [CustomStringConvertible] = []
    
    func update(with item: CustomStringConvertible) {
        data.append(item)
        // ⚠️ 即使 Release 不打印，description 也会被立即求值
        Logger.log(item.description)
    }
}

• 浪费 CPU：复杂 description 可能拼接大量字符串。
• 浪费内存：中间结果在 Release 版毫无用处。

上正菜：用 @autoclosure 实现"真正只在需要时才计算"

改一行签名即可

class Logger {
    // 1. 自动把调用处的表达式包成 () -> String
    static func log(_ message: @autoclosure () -> String) {
        #if DEBUG
        print(message())        // 2. 只有 DEBUG 才执行闭包
        #endif
    }
}

调用方零感知

ds.update(with: Vehicle(name: "BMW"))
// 调用处完全像传值，无需手写大括号

内部流程

阶段	实际行为
编译期	把表达式 item.description包成 { item.description }
运行期	只有 message()被调用时才执行闭包

进阶玩法

与 ?? 运算符同源

标准库定义：

public func ?? <T>(optional: T?, defaultValue: @autoclosure () -> T) -> T {
    optional != nil ? optional! : defaultValue()
}

• defaultValue 只有在前者为 nil 才执行，避免无谓开销。

自定义断言

func myAssert(_ condition: Bool, _ message: @autoclosure () -> String = "") {
    #if DEBUG
    if !condition {
        print("断言失败: \(message())")
    }
    #endif
}

// 使用
myAssert(score > 0, "分数必须为正，当前值：\(score)")
// 若断言通过，字符串插值不会被执行

短路求值

func logIf(_ condition: Bool, _ msg: @autoclosure () -> String) {
    guard condition else { return }
    print(msg())
}

logIf(isDebug, "昂贵计算结果：\(heavyCompute())")   // 非 Debug 直接短路

使用 checklist

场景	是否适合 @autoclosure
日志、断言、调试信息	✅ 延迟 + 避免副作用
复杂默认值	✅ 与 ??同理
需要多次读取的闭包	❌ 每次调用都会重新求值，缓存请手动处理
需要捕获可变量的闭包	⚠️ 捕获的是表达式当时的值，注意值语义

一句话总结

@autoclosure 是 Swift 给你的"惰性开关"：

调用方像传值，接收方像拿闭包，只在真正需要时才执行表达式。

把它用在"可能昂贵、可能无效、可能副作用"的参数上，代码立刻更省、更快、更安全。