iOS模态跳转后数据同步：如何局部修改FirstController的photosList

Hey there! I see exactly what's going on here. The problem stems from your customStruct being a value type—when you pass photosList to ImageDetailViewController, you're actually sending a copy of the array and all the structs inside it. So any changes you make in the detail page only affect that local copy, not the original array in FirstController. Let's go through a few solid solutions to fix this:

Solution 1: Turn Your Struct into a Class (Easiest for Simple Cases) #

Since classes are reference types, passing them around means you're working with the same underlying object instead of a copy. Here's how to adjust your code:

First, update your custom type from a struct to a class:

class CustomPhoto { // Rename to match your actual struct name
    var imageLikes: Int
    var viewCount: Int
    // Add all other properties your struct had here
    
    init(imageLikes: Int, viewCount: Int /* include other init parameters */) {
        self.imageLikes = imageLikes
        self.viewCount = viewCount
    }
}

Then in FirstController, your array becomes [CustomPhoto]:

class FirstController: UIViewController { 
    var photosList: [CustomPhoto] = [Photo1, Photo2, Photo3] // Photo1/2/3 are now class instances
    
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) { 
        if segue.identifier == "photofull" { 
            if let fullImageViewController = segue.destination as? ImageDetailViewController { 
                fullImageViewController.photosList = photosList 
            } 
        } 
    } 
}

Now when you modify photosList[1].imageLikes += 1 in ImageDetailViewController, it will directly update the object in FirstController's array—no extra work needed!

Solution 2: Use a Closure Callback (Great if You Want to Keep Structs) #

If you prefer to keep customStruct as a value type, a closure lets the detail view controller "report back" changes to the parent. Here's how:

In ImageDetailViewController, add a closure property that accepts the index of the modified item and the updated struct:

class ImageDetailViewController: UIViewController {
    var photosList: [customStruct] = []
    var onPhotoUpdated: ((Int, customStruct) -> Void)? // Closure to send updates back
    
    // Example method for incrementing likes
    func incrementLikes(at index: Int) {
        var updatedPhoto = photosList[index]
        updatedPhoto.imageLikes += 1
        photosList[index] = updatedPhoto
        // Call the closure to notify FirstController
        onPhotoUpdated?(index, updatedPhoto)
    }
}

Then in FirstController's prepare(for:sender:) method, set up the closure to update your original array:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) { 
    if segue.identifier == "photofull" { 
        if let fullImageViewController = segue.destination as? ImageDetailViewController { 
            fullImageViewController.photosList = photosList 
            // Set up the callback closure (use [weak self] to avoid retain cycles)
            fullImageViewController.onPhotoUpdated = { [weak self] index, updatedPhoto in
                guard let self = self else { return }
                self.photosList[index] = updatedPhoto
                // Refresh your UI here if needed (e.g., table view)
                // self.tableView.reloadRows(at: [IndexPath(row: index, section: 0)], with: .automatic)
            }
        }
    }
}

Solution 3: Delegate Pattern (Best for Complex Interactions) #

For more complex communication between view controllers, a delegate protocol is a clean, scalable approach.

First, define a protocol in ImageDetailViewController:

protocol ImageDetailDelegate: AnyObject {
    func detailViewController(_ vc: ImageDetailViewController, didUpdatePhoto photo: customStruct, at index: Int)
}

class ImageDetailViewController: UIViewController {
    var photosList: [customStruct] = []
    weak var delegate: ImageDetailDelegate? // Weak to prevent memory leaks
    
    // Example method for incrementing likes
    func incrementLikes(at index: Int) {
        var updatedPhoto = photosList[index]
        updatedPhoto.imageLikes += 1
        photosList[index] = updatedPhoto
        // Notify the delegate of the change
        delegate?.detailViewController(self, didUpdatePhoto: updatedPhoto, at: index)
    }
}

Then make FirstController conform to the protocol and set itself as the delegate:

class FirstController: UIViewController, ImageDetailDelegate { 
    var photosList: [customStruct] = [Photo1, Photo2, Photo3] 
    
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) { 
        if segue.identifier == "photofull" { 
            if let fullImageViewController = segue.destination as? ImageDetailViewController { 
                fullImageViewController.photosList = photosList 
                fullImageViewController.delegate = self
            } 
        } 
    } 

    // Implement the delegate method
    func detailViewController(_ vc: ImageDetailViewController, didUpdatePhoto photo: customStruct, at index: Int) {
        photosList[index] = photo
        // Refresh your UI here if needed
        // tableView.reloadRows(at: [IndexPath(row: index, section: 0)], with: .automatic)
    }
}

Which One Should You Choose? #

• Go with Solution 1 if your data model doesn't need to be immutable (structs are great for fixed data, but classes simplify mutable state sharing).
• Use Solution 2 for simple, one-off updates where you want to retain your struct's value-type benefits.
• Pick Solution 3 if you have multiple types of updates or need a structured, reusable communication pattern.

内容的提问来源于stack exchange，提问作者Ryan B.