Swift中UITableView不可见单元格使用及进度条更新nil问题求助

Hey there! This is a super common pitfall when working with UITableView—let's break down your questions clearly, with actionable solutions.

Why cellForRowAt(IndexPath) Returns Nil for Off-Screen Cells #

First off, let's get to the root of the problem: UITableView is built for performance, so it only keeps cells that are currently visible (or just barely off-screen for smooth scrolling) in memory. Any cell scrolled far out of view gets either recycled into the reuse pool (to be repurposed for new rows) or deallocated entirely. That's why calling cellForRowAt on an off-screen index path returns nil—there's no active cell instance for that row right now.

Solution: Drive Updates with Your Data Source #

The correct approach is to separate your data from your UI. Instead of trying to modify cells directly, update your data model first, then let the tableView handle refreshing the UI (either immediately for visible cells, or when the cell comes back into view). Here's how to implement this:

1. Store Progress Values in a Data Source
   Create an array or dictionary to track progress for each row. For example:

   var taskProgress: [Double] = Array(repeating: 0.0, count: 20) // 20 tasks, all starting at 0%
   

2. Update the Data Source & Refresh Appropriately
   When a task's progress changes, update the data source first. Then, check if the corresponding cell is visible—if it is, update the progress bar directly. If not, the data source change will ensure the cell gets the latest value when it's scrolled back into view:

   func updateProgress(forTaskIndex index: Int, newProgress: Double) {
       guard index < taskProgress.count else { return }
       // 1. Update the data source first
       taskProgress[index] = newProgress
       
       let indexPath = IndexPath(row: index, section: 0)
       // 2. If the cell is visible, update it immediately
       if let visibleCell = tableView.cellForRow(at: indexPath) as? ProgressCell {
           visibleCell.progressView.setProgress(newProgress, animated: true)
       }
       // 3. If not visible, no extra work needed—cell will get the new value when it's dequeued later
   }
   

3. Set Progress in cellForRowAt
   Make sure your cell configuration pulls the latest progress from the data source every time it's created or reused:

   override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
       let cell = tableView.dequeueReusableCell(withIdentifier: "ProgressCell", for: indexPath) as! ProgressCell
       // Always pull the latest value from the data source to avoid reuse bugs
       cell.progressView.progress = taskProgress[indexPath.row]
       cell.taskNameLabel.text = "Task \(indexPath.row + 1)"
       return cell
   }
   

If you want a smooth refresh for when the cell comes into view, you can also use reloadRows(at:with:), but note this will trigger a small animation and re-run cellForRowAt:

tableView.reloadRows(at: [indexPath], with: .automatic)

How to Work With Off-Screen UITableViewCells in Swift #

Off-screen cells aren't meant to be directly manipulated—they either don't exist yet or are in the reuse pool waiting to be repurposed. Instead, you work with them indirectly by leveraging UITableView's reuse mechanism and data source pattern:

• Always Trust Your Data Source: Every cell's state (progress, text, images, etc.) should come from your data model. Never store UI state directly in cells, since they get reused.
• Leverage the Reuse Pool: UITableView automatically recycles cells to save memory. Your job is to reset the cell's state in cellForRowAt to match the current row's data (this prevents old data from appearing in new rows).
• Prep Cells Before They Appear: Use tableView(_:willDisplay:forRowAt:) to do last-minute setup before a cell enters the screen. This is perfect for starting tasks like fetching data or updating progress right before the user sees the cell:

  override func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
      guard let progressCell = cell as? ProgressCell else { return }
      // Update progress one last time before the cell is visible
      progressCell.progressView.setProgress(taskProgress[indexPath.row], animated: true)
  }
  

• Never Force-Create Off-Screen Cells: Manually dequeuing cells and storing references to them wastes memory and breaks the reuse system. Let UITableView handle cell creation and recycling—it's designed to do this efficiently.

Key Takeaway #

UITableView is optimized for performance by only keeping necessary cells in memory. The secret to working with both visible and off-screen cells is to keep your data source as the single source of truth, and let the table view handle updating the UI when cells are needed.

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