Swift 链式调用的理解

一、链式调用的核心原理：返回 self

1. 为什么返回 self 能实现链式调用？

• 方法调用的连续性：在 Swift 中，方法调用后返回的对象类型决定了后续调用的可能性。如果一个方法返回的是当前对象（self），那么连续调用下一个方法时，Swift 会将返回的 self 作为调用主体。
• 语法结构：Swift 允许连续的点操作（.），例如 a().b().c()。每个方法的返回值必须兼容后续方法的调用主体（通常是同一类型）。

2. 示例代码详解：

class Builder {
    var result: String = ""
    
    // 方法返回 self，允许链式调用
    @discardableResult
    func addText(_ text: String) -> Builder {
        result += text + " "
        return self
    }
    
    func build() -> String {
        return result.trimmingCharacters(in: .whitespaces)
    }
}

let builtString = Builder()
    .addText("Hello")   // 返回 Builder 实例
    .addText("World")   // 接收上一个 addText 返回的 Builder 实例
    .build()            // 最终调用 build 方法

• 关键点：
  • addText 返回 Builder 类型的 self，因此 .addText("World") 的调用主体是同一个 Builder 实例。
  • build() 返回 String，结束链式调用。

---

二、闭包实现链式调用的原理与细节

1. 闭包返回对象自身

• 闭包作为方法参数：可以通过闭包返回对象自身，实现链式调用。
• 示例代码详解：

class Adder {
    var currentValue: Double = 0
    
    // 闭包返回 self
    func add(value: Double, then action: (Adder) -> Void) -> Adder {
        currentValue += value
        action(self) // 将 self 传入闭包
        return self
    }
    
    func getResult() -> String {
        return String(format: "%.2f", currentValue)
    }
}

// 链式调用
let result = Adder()
    .add(value: 1.111) { _ in }  // 闭包接收 self
    .add(value: 2.222) { _ in }  // 闭包接收 self
    .getResult()

• 关键点：
  • add 方法的闭包参数接收 self，允许在闭包内操作对象状态。
  • 返回 self 后，可以继续调用 add 方法。

---

三、可选链式调用（Optional Chaining）详解

1. 可选链式调用的语法

• 语法格式：optional?.propertyOrMethod()
• 作用：如果 optional 为 nil，整个链式调用返回 nil，而不会崩溃。

2. 示例代码详解：

class Person {
    var residence: Residence?
}

class Residence {
    var address: Address?
}

class Address {
    var street: String?
}

let person = Person()
person.residence = Residence()
person.residence?.address = Address()
person.residence?.address?.street = "Main St"

// 可选链式调用
if let street = person.residence?.address?.street {
    print(street) // 输出 "Main St"
} else {
    print("Address not available")
}

• 关键点：
  • person.residence?：如果 residence 为 nil，后续调用直接返回 nil。
  • ?.address?：继续检查 address 是否为 nil。
  • ?.street：最终访问 street 属性。

---

四、扩展方法支持链式调用的实现

1. 扩展方法的语法

• 语法格式：extension TypeName { ... }
• 作用：为已有类型添加方法或属性。

2. 示例代码详解：

extension String {
    @discardableResult
    func appendIfNotEmpty(_ text: String) -> String {
        if !text.isEmpty {
            return self + text
        }
        return self
    }
}

let message = "Hello".appendIfNotEmpty(" World").appendIfNotEmpty("")
print(message) // 输出 "Hello World"

• 关键点：
  • @discardableResult：告诉编译器忽略返回值，避免未使用的返回值警告。
  • appendIfNotEmpty 返回 String 类型，允许连续调用。

---

五、@discardableResult 的作用与必要性

1. 什么是 @discardableResult？

• 作用：标注方法的返回值可以被忽略，即使没有显式使用返回值。
• 必要性：链式调用中，开发者通常只关心最终结果，而中间方法的返回值（self）无需显式赋值。

2. 示例对比：

// 不使用 @discardableResult
func addText(_ text: String) -> Builder {
    // ...
}

// 调用时必须显式使用返回值（否则报错）
_ = Builder().addText("Hello")

// 使用 @discardableResult
@discardableResult
func addText(_ text: String) -> Builder {
    // ...
}

// 调用时可忽略返回值
Builder().addText("Hello")

---

六、实际应用场景详解

1. UI 构建中的链式调用

let button = UIButton()
    .setTitle("Login", for: .normal)     // 设置标题
    .setTitleColor(.blue, for: .normal)  // 设置颜色
    .setBackgroundColor(.lightGray)      // 设置背景色
    .addTarget(self, action: #selector(buttonTapped), for: .touchUpInside) // 添加事件

• 关键点：
  • 每个方法返回 UIButton 实例，允许连续调用。
  • addTarget 方法需要返回 UIButton 才能继续链式调用（需自定义扩展或使用库）。

2. 数据处理中的链式调用

let result = [1, 2, 3, 4, 5]
    .filter { $0 % 2 == 0 }    // 过滤偶数
    .map { $0 * 2 }           // 乘以 2
    .reduce(0, +)             // 求和

• 关键点：
  • 每个高阶函数返回新的数组或值，形成链式调用。
  • filter 返回 [Int]，map 返回 [Int]，reduce 返回 Int。

---

七、链式调用的性能与注意事项

1. 性能影响

• 内存开销：链式调用中的中间结果可能生成临时对象（如数组、字符串），需注意内存占用。
• 闭包捕获：闭包中捕获 self 时，需避免强引用循环（使用 [weak self] 或 [unowned self]）。

2. 注意事项

• 过度链式调用：长链式调用可能导致代码可读性下降，建议拆分复杂逻辑。
• 错误处理：链式调用中若某个方法抛出错误，需使用 do-catch 处理。

---

八、总结：链式调用的关键要素与技巧

要素	解释
返回 self	方法返回当前对象实例，允许连续调用。
@discardableResult	忽略中间方法的返回值，避免编译器警告。
可选链式调用 ?	安全访问可选值的属性或方法，避免崩溃。
扩展方法	为已有类型添加链式调用方法，无需修改原始类。
闭包链式调用	通过闭包传递对象自身，实现更灵活的链式逻辑。
性能与可读性	平衡链式调用的简洁性与代码的可维护性，避免过度链式调用。