Swift中多ViewController数据收集的最佳实现方案咨询

架构老林

2026-5-27

嘿，这个场景在iOS开发里简直是家常便饭！我给你整理了几个最实用的方案，你可以根据自己项目的复杂度和VC之间的关系来挑：

1. 单例模式（Singleton）

这应该是最容易上手的方案了——搞一个全局的「数据收集器」单例，每个VC直接往里面塞数据就行，最后一个VC直接从单例里取所有数据。

适用场景：数据结构简单、VC之间跳转关系不复杂的小项目，或者只是临时快速验证功能的时候。

优点：不用费劲传值，全局都能访问，代码量极少。
缺点：耦合度太高了，单例里的数据会一直占着内存，而且写单元测试的时候会很头疼（因为单例是全局状态，容易互相影响）。

举个Swift的例子：

class DataCollector {
    static let shared = DataCollector()
    private init() {} // 防止外部初始化
    
    var username: String?
    var phoneNumber: String?
    var address: String?
}

// 在第一个VC里
DataCollector.shared.username = "JohnDoe"

// 在最后一个VC里
let allData = DataCollector.shared
print(allData.username, allData.phoneNumber, allData.address)

2. 委托模式（Delegate）

这可是iOS官方最推崇的设计模式之一，特别适合导航栈里的「链式VC」（比如A→B→C→D）。思路是每个VC收集完数据后，通过代理把数据传给上一级VC，上一级保存好，最后到最后一个VC的时候，就能从前面的VC拿到所有数据；或者反过来，最后一个VC通过代理向上请求所有数据。

适用场景：VC之间是明确的线性跳转关系，想要低耦合、符合iOS设计规范的场景。

优点：解耦性好，每个VC只需要关心自己的部分，不用管其他VC怎么处理数据；而且官方文档里到处都是这种写法，团队协作的时候大家都看得懂。
缺点：如果VC链特别长（比如5个以上），每个VC都要写代理协议，代码会有点繁琐。

举个例子，假设BVC需要把收集到的手机号传给AVC：

// BVC的代理协议
protocol BVCDelegate: AnyObject {
    func didCollectPhoneNumber(_ number: String)
}

class BVC: UIViewController {
    weak var delegate: BVCDelegate?
    var phoneTextField: UITextField!
    
    func submitButtonTapped() {
        guard let number = phoneTextField.text else { return }
        delegate?.didCollectPhoneNumber(number)
        navigationController?.popViewController(animated: true)
    }
}

// AVC遵守代理
class AVC: UIViewController, BVCDelegate {
    var collectedPhoneNumber: String?
    
    func pushToBVC() {
        let bvc = BVC()
        bvc.delegate = self
        navigationController?.pushViewController(bvc, animated: true)
    }
    
    // 实现代理方法
    func didCollectPhoneNumber(_ number: String) {
        collectedPhoneNumber = number
    }
    
    // 之后push到最后一个VC的时候，把collectedPhoneNumber传过去
}

3. 闭包（Closure）

和代理模式思路差不多，但用Swift的闭包来实现会更简洁，不用写繁琐的代理协议。特别适合VC链不长的情况。

适用场景：线性跳转的VC，想要代码更紧凑、少写模板代码的时候。

优点：代码量少，不用定义代理协议，逻辑更集中。
缺点：如果闭包嵌套太多（比如跳3个以上VC都用闭包传值），容易写出「金字塔代码」，可读性会下降。

还是刚才的例子，用闭包实现：

class BVC: UIViewController {
    var onPhoneNumberCollected: ((String) -> Void)?
    var phoneTextField: UITextField!
    
    func submitButtonTapped() {
        guard let number = phoneTextField.text else { return }
        onPhoneNumberCollected?(number)
        navigationController?.popViewController(animated: true)
    }
}

class AVC: UIViewController {
    var collectedPhoneNumber: String?
    
    func pushToBVC() {
        let bvc = BVC()
        bvc.onPhoneNumberCollected = { [weak self] number in
            self?.collectedPhoneNumber = number
        }
        navigationController?.pushViewController(bvc, animated: true)
    }
}

4. 共享模型对象传递

搞一个统一的数据模型（比如UserProfileModel），在第一个VC里初始化好，然后每次push下一个VC的时候，把这个模型传过去——每个VC只负责修改模型里对应自己的属性，最后一个VC直接用这个模型的所有属性就行。

适用场景：VC之间是严格的线性跳转（A→B→C→D），每个VC只负责模型的一部分字段。

优点：逻辑特别直观，所有数据都在一个模型里，不用来回传零散的数据；而且解耦性也不错，每个VC只关心自己负责的字段。
缺点：如果VC跳转有分支（比如A可以跳B也可以跳C），多个VC修改同一个模型的时候要注意线程安全（比如用DispatchQueue或者加锁），不然容易出现数据混乱。

示例：

// 定义模型
struct UserProfileModel {
    var username: String?
    var phoneNumber: String?
    var address: String?
}

// AVC里初始化模型
class AVC: UIViewController {
    var userProfile = UserProfileModel()
    
    func pushToBVC() {
        let bvc = BVC()
        bvc.userProfile = userProfile // 传递模型
        navigationController?.pushViewController(bvc, animated: true)
    }
}

// BVC里修改模型的手机号
class BVC: UIViewController {
    var userProfile: UserProfileModel!
    var phoneTextField: UITextField!
    
    func submitButtonTapped() {
        userProfile.phoneNumber = phoneTextField.text
        let cvc = CVC()
        cvc.userProfile = userProfile // 继续传递模型
        navigationController?.pushViewController(cvc, animated: true)
    }
}

// 最后一个CVC里直接用模型
class CVC: UIViewController {
    var userProfile: UserProfileModel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        print("用户名：\(userProfile.username ?? "")")
        print("手机号：\(userProfile.phoneNumber ?? "")")
    }
}

5. 通知中心（Notification Center）

如果你的VC之间没有直接的跳转关系（比如一个VC在tabBar的另一个页面），或者需要多个VC同时接收数据，通知中心就很合适。每个VC收集完数据后发送一个通知，最后一个VC监听所有通知，把数据攒起来。

适用场景：VC之间没有直接跳转关系、需要多接收者的场景，或者跨模块传递数据。

优点：完全解耦，发送方不用知道谁在接收数据，接收方也不用知道数据来自哪里。
缺点：调试起来比较麻烦，容易出现重复监听的问题；而且如果忘记移除观察者，还可能导致内存泄漏。

示例：

// 定义通知名称
extension Notification.Name {
    static let didCollectUsername = Notification.Name("didCollectUsername")
    static let didCollectPhoneNumber = Notification.Name("didCollectPhoneNumber")
}

// 第一个VC发送通知
class AVC: UIViewController {
    func submitUsername() {
        let username = "JohnDoe"
        NotificationCenter.default.post(name: .didCollectUsername, object: username)
    }
}

// 最后一个VC监听通知
class FinalVC: UIViewController {
    var username: String?
    var phoneNumber: String?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 添加观察者
        NotificationCenter.default.addObserver(self, selector: #selector(didReceiveUsername(_:)), name: .didCollectUsername, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(didReceivePhoneNumber(_:)), name: .didCollectPhoneNumber, object: nil)
    }
    
    @objc func didReceiveUsername(_ notification: Notification) {
        username = notification.object as? String
    }
    
    @objc func didReceivePhoneNumber(_ notification: Notification) {
        phoneNumber = notification.object as? String
    }
    
    // 记得在deinit里移除观察者
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

6. 依赖注入（Dependency Injection）

这是更优雅、更适合大型项目的方案——搞一个专门的「数据管理器」，把它注入到每个需要收集数据的VC里。每个VC通过这个管理器保存数据，最后一个VC也通过这个管理器获取所有数据。

适用场景：大型项目，需要高可维护性、可测试性的场景，比如用MVVM、VIPER架构的时候。

优点：解耦性极强，VC不直接依赖全局状态，单元测试的时候可以轻松替换成模拟的管理器；符合SOLID设计原则。
缺点：需要额外的代码来管理注入，比如用依赖注入容器，初期学习成本有点高。

示例：

// 定义数据管理器协议
protocol DataManaging {
    func saveUsername(_ username: String)
    func savePhoneNumber(_ number: String)
    func getAllData() -> [String: String?]
}

// 实现数据管理器
class DataManager: DataManaging {
    private var username: String?
    private var phoneNumber: String?
    
    func saveUsername(_ username: String) {
        self.username = username
    }
    
    func savePhoneNumber(_ number: String) {
        self.phoneNumber = number
    }
    
    func getAllData() -> [String: String?] {
        return ["username": username, "phoneNumber": phoneNumber]
    }
}

// 注入到VC里
class AVC: UIViewController {
    private let dataManager: DataManaging
    
    // 通过初始化方法注入
    init(dataManager: DataManaging) {
        self.dataManager = dataManager
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    func submitUsername() {
        dataManager.saveUsername("JohnDoe")
    }
}

// 最后一个VC里获取数据
class FinalVC: UIViewController {
    private let dataManager: DataManaging
    
    init(dataManager: DataManaging) {
        self.dataManager = dataManager
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        let allData = dataManager.getAllData()
        print(allData)
    }
}

// 使用的时候
let dataManager = DataManager()
let avc = AVC(dataManager: dataManager)
let finalVC = FinalVC(dataManager: dataManager)

怎么选最合适的方案？

给你一个快速决策的参考：

小项目、快速验证：单例模式或共享模型传递
线性导航栈、低耦合：委托模式或闭包
跨VC/跨模块、多接收者：通知中心
大型项目、追求可维护性：依赖注入

其实很多时候也可以组合使用，比如用共享模型+委托，或者依赖注入+模型，根据实际情况调整就行！

内容的提问来源于stack exchange，提问作者Vineet Ravi

Swift中多ViewController数据收集的最佳实现方案咨询

1. 单例模式（Singleton） #

2. 委托模式（Delegate） #

3. 闭包（Closure） #

4. 共享模型对象传递 #

5. 通知中心（Notification Center） #

6. 依赖注入（Dependency Injection） #

怎么选最合适的方案？ #