Table View Cell独立定时器实现求助：点击启动无法独立运行

Hey there! Let's sort out how to get each of your Table View Cells running their own independent timers. The issue you're facing usually comes from reusing a single timer instance across all cells, or not properly linking each timer to its specific cell's data (instead of the cell itself, since cells get reused constantly as you scroll).

The Right Approach: Bind Timers to Your Data Model #

Instead of storing timers directly in Table View Cells (which get recycled), attach each timer to a data model object. This way, each timer is tied to the data it's tracking, not the reusable cell UI element.

Step 1: Create a Data Model for Timer Items #

First, define a model to hold each timer's state and instance. Here's an example in Swift:

struct TimerItem {
    let id: UUID // Unique identifier for each item
    var isRunning: Bool // Tracks if the timer is active
    var elapsedTime: TimeInterval // Tracks how much time has passed
    var timer: Timer? // The timer instance for this specific item
}

For Objective-C, you'd create a similar NSObject subclass with properties for isRunning, elapsedTime, and a NSTimer instance.

Step 2: Manage Your Data Source #

Use a mutable array of TimerItem as your Table View's data source. This lets you update timer states as needed:

var timerItems: [TimerItem] = []

Initialize this array with your starting timer items (e.g., empty timers with elapsedTime = 0 and isRunning = false).

Step 3: Handle Cell Selection & Timer Control #

When a cell is tapped, find the corresponding TimerItem in your data source, then start/stop its timer. Make sure to update the data source and refresh only the affected cell:

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    tableView.deselectRow(at: indexPath, animated: true)
    
    // Get a mutable copy of the target item
    var currentItem = timerItems[indexPath.row]
    
    if currentItem.isRunning {
        // Stop the timer
        currentItem.timer?.invalidate()
        currentItem.timer = nil
        currentItem.isRunning = false
    } else {
        // Start the timer with weak self to avoid retain cycles
        currentItem.timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            guard let self = self else { return }
            
            // Update elapsed time
            currentItem.elapsedTime += 1
            // Save the updated item back to the data source
            self.timerItems[indexPath.row] = currentItem
            // Refresh only the affected cell (no need to reload the whole table!)
            self.tableView.reloadRows(at: [indexPath], with: .automatic)
        }
        currentItem.isRunning = true
    }
    
    // Save the updated item back to the data source
    timerItems[indexPath.row] = currentItem
}

Step 4: Configure Cells From the Data Model #

In cellForRowAt, configure your cell's UI using the state from the TimerItem—this ensures reused cells always show the correct timer state:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "TimerCell", for: indexPath) as! TimerCell
    let item = timerItems[indexPath.row]
    
    // Update UI elements (customize these to match your cell's design)
    cell.timeLabel.text = String(format: "Elapsed: %.0fs", item.elapsedTime)
    cell.toggleButton.setTitle(item.isRunning ? "Stop" : "Start", for: .normal)
    
    return cell
}

Step 5: Clean Up Timers When Needed #

To prevent memory leaks, stop all timers when the view disappears:

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    
    // Invalidate all active timers and reset their state
    for index in timerItems.indices {
        timerItems[index].timer?.invalidate()
        timerItems[index].timer = nil
        timerItems[index].isRunning = false
    }
}

Why Your Original Setup Failed #

Chances are you were either:

• Using a single global timer that updated all cells when it fired, or
• Storing the timer directly in the Table View Cell (which gets reused, leading to multiple cells sharing the same timer instance as you scroll).

By tying each timer to a data model, you ensure each timer only affects its own data and corresponding cell.

Give this approach a shot—this should get each cell's timer running independently without interfering with others. Let me know if you hit any roadblocks!

内容的提问来源于stack exchange，提问作者Denisson de Souza