iOS开发：点击Cell后如何将已下载图片传递至另一个视图控制器

嘿，兄弟，我刚好在项目里处理过一模一样的场景，结合你已经做了URLSession下载+缓存的前提，给你几个实用的方案，都能完美解决图片传递的问题：

方案1：直接传递UIImage对象（最简单直接） #

如果你的Cell里的图片已经完成下载并缓存，那在点击Cell的时候，直接把对应的UIImage传给详情视图控制器就好。

代码示例： #

// 列表视图控制器的tableView点击事件
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    // 这里假设你有一个存储已下载图片的数组，或者直接从Cell的imageView获取
    guard let selectedCell = tableView.cellForRow(at: indexPath) as? CustomImageCell,
          let targetImage = selectedCell.imageView?.image else {
        return
    }
    
    let detailVC = DetailViewController()
    detailVC.displayImage = targetImage
    navigationController?.pushViewController(detailVC, animated: true)
}

// 详情视图控制器
class DetailViewController: UIViewController {
    var displayImage: UIImage?
    private let mainImageView = UIImageView()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupImageView()
        mainImageView.image = displayImage
    }
    
    private func setupImageView() {
        mainImageView.frame = view.bounds
        mainImageView.contentMode = .scaleAspectFit
        view.addSubview(mainImageView)
    }
}

⚠️ 注意：如果用户点击的是正在下载中的Cell，这时候imageView?.image可能是占位图或者nil，这时候你可以结合你的缓存逻辑，先判断缓存里有没有，没有的话等待下载完成再跳转，或者直接用下面的方案2。

方案2：传递图片缓存标识（推荐，更高效） #

如果你的图片比较大，直接传UIImage会占用较多内存，更推荐传递图片的唯一标识（比如图片的URL字符串、你自定义的缓存Key），让详情VC自己从缓存里读取图片。

代码示例： #

// 列表视图控制器的点击事件
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let imageURL = yourImageURLArray[indexPath.row] // 假设你存储了所有图片的URL数组
    let detailVC = DetailViewController()
    detailVC.targetImageURL = imageURL
    navigationController?.pushViewController(detailVC, animated: true)
}

// 详情视图控制器
class DetailViewController: UIViewController {
    var targetImageURL: URL?
    private let mainImageView = UIImageView()
    // 假设你有一个全局的缓存单例
    private let imageCache = ImageCache.shared

    override func viewDidLoad() {
        super.viewDidLoad()
        setupImageView()
        loadImageFromCache()
    }
    
    private func loadImageFromCache() {
        guard let url = targetImageURL else { return }
        let cacheKey = url.absoluteString
        
        // 先从内存缓存取
        if let cachedImage = imageCache.memoryCache.object(forKey: cacheKey as NSString) as? UIImage {
            mainImageView.image = cachedImage
            return
        }
        
        // 内存没有就从磁盘缓存取
        if let diskImageData = try? Data(contentsOf: imageCache.diskCacheURL.appendingPathComponent(cacheKey)),
           let diskImage = UIImage(data: diskImageData) {
            mainImageView.image = diskImage
            // 同步到内存缓存
            imageCache.memoryCache.setObject(diskImage, forKey: cacheKey as NSString)
            return
        }
        
        // 极端情况：缓存失效，重新下载（你已经做了防重复下载，这里可以复用你的下载逻辑）
        downloadImage(from: url)
    }
    
    private func downloadImage(from url: URL) {
        URLSession.shared.dataTask(with: url) { [weak self] data, _, error in
            guard let self = self, let data = data, let image = UIImage(data: data), error == nil else { return }
            
            DispatchQueue.main.async {
                self.mainImageView.image = image
                // 重新存入缓存
                self.imageCache.storeImage(image, forKey: url.absoluteString)
            }
        }.resume()
    }
    
    private func setupImageView() {
        mainImageView.frame = view.bounds
        mainImageView.contentMode = .scaleAspectFit
        view.addSubview(mainImageView)
    }
}

// 假设你的缓存单例大概是这样的
class ImageCache {
    static let shared = ImageCache()
    let memoryCache = NSCache<NSString, UIImage>()
    let diskCacheURL: URL = {
        let urls = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
        return urls[0].appendingPathComponent("ImageCache")
    }()
    
    private init() {
        // 创建磁盘缓存目录
        try? FileManager.default.createDirectory(at: diskCacheURL, withIntermediateDirectories: true)
    }
    
    func storeImage(_ image: UIImage, forKey key: String) {
        // 存内存
        memoryCache.setObject(image, forKey: key as NSString)
        // 存磁盘
        if let data = image.pngData() {
            try? data.write(to: diskCacheURL.appendingPathComponent(key))
        }
    }
}

这个方案的优势是节省内存，而且即使图片还在下载中，详情VC也能复用你的下载逻辑，自动等待下载完成后展示，完全适配你的缓存机制。

方案3：用闭包回调（适合复杂场景） #

如果你的图片加载逻辑比较复杂，比如需要在列表VC里监听下载完成后再通知详情VC，可以用闭包回调的方式：

代码示例： #

// 列表VC的点击事件
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let imageURL = yourImageURLArray[indexPath.row]
    let detailVC = DetailViewController()
    
    // 传入获取图片的闭包
    detailVC.loadImageClosure = { [weak self] completion in
        guard let self = self else { return }
        if let cachedImage = ImageCache.shared.image(forKey: imageURL.absoluteString) {
            completion(cachedImage)
            return
        }
        // 如果没缓存，触发下载
        self.downloadImage(from: imageURL) { image in
            completion(image)
        }
    }
    
    navigationController?.pushViewController(detailVC, animated: true)
}

// 详情VC
class DetailViewController: UIViewController {
    var loadImageClosure: ((UIImage?) -> Void)?
    private let mainImageView = UIImageView()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupImageView()
        loadImageClosure? { [weak self] image in
            DispatchQueue.main.async {
                self?.mainImageView.image = image
            }
        }
    }
    
    // 省略setupImageView方法...
}

这个方案灵活性最高，适合一些需要额外处理的复杂场景，但一般来说方案2就足够用了。

内容的提问来源于stack exchange，提问作者Mike Koofer