多分组UITableView中自定义Cell内UITextField的键盘Next跳转实现

Ah, right—when you have multiple sections in your UITableView, the simple tag = indexPath.row approach falls apart because rows reset to 0 per section, and you can't just increment the tag blindly. Let's fix this properly with two solid approaches, depending on your preference:

方法1：用关联对象存储IndexPath（更可靠） #

This approach avoids tag collisions entirely by attaching the exact IndexPath of the cell directly to the UITextField. Here's how to implement it:

First, add an extension to UITextField to store the IndexPath using associated objects:

import ObjectiveC

// Create a unique key for the associated object
private var IndexPathAssociationKey: UInt8 = 0

extension UITextField {
    var indexPath: IndexPath? {
        get {
            return objc_getAssociatedObject(self, &IndexPathAssociationKey) as? IndexPath
        }
        set {
            objc_setAssociatedObject(self, &IndexPathAssociationKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
}

Then, in your cellForRowAt method, set the delegate and attach the IndexPath to the text field:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "YourCustomCellID", for: indexPath) as! YourCustomTableViewCell
    
    // Configure your cell
    cell.textField.delegate = self
    cell.textField.indexPath = indexPath // Attach the index path
    
    return cell
}

Finally, implement the textFieldShouldReturn delegate method to handle the Next button tap:

func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    guard let currentIndexPath = textField.indexPath else {
        textField.resignFirstResponder()
        return true
    }
    
    let currentSection = currentIndexPath.section
    let currentRow = currentIndexPath.row
    let rowsInSection = tableView.numberOfRows(inSection: currentSection)
    
    // Calculate the next index path
    var nextIndexPath: IndexPath?
    if currentRow < rowsInSection - 1 {
        // Move to the next row in the same section
        nextIndexPath = IndexPath(row: currentRow + 1, section: currentSection)
    } else {
        // Move to the first row of the next section (if it exists)
        if currentSection < tableView.numberOfSections - 1 {
            nextIndexPath = IndexPath(row: 0, section: currentSection + 1)
        }
        // If no next section exists, we'll resign the responder
    }
    
    // Focus the next text field or dismiss the keyboard
    if let nextIP = nextIndexPath, let nextCell = tableView.cellForRow(at: nextIP) as? YourCustomTableViewCell {
        nextCell.textField.becomeFirstResponder()
    } else {
        textField.resignFirstResponder()
    }
    
    return true
}

方法2：用编码后的Tag（更轻量） #

If you prefer to stick with tags, you can encode both the section and row into a single integer tag to avoid collisions. Just make sure the multiplier you use is larger than the maximum number of rows you'll have in any section (e.g., 1000 is safe for most cases).

In cellForRowAt:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "YourCustomCellID", for: indexPath) as! YourCustomTableViewCell
    
    cell.textField.delegate = self
    // Encode section and row into tag: section * 1000 + row
    cell.textField.tag = indexPath.section * 1000 + indexPath.row
    
    return cell
}

Then in textFieldShouldReturn:

func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    let currentTag = textField.tag
    let currentSection = currentTag / 1000
    let currentRow = currentTag % 1000
    
    let rowsInSection = tableView.numberOfRows(inSection: currentSection)
    var nextTag: Int?
    
    if currentRow < rowsInSection - 1 {
        // Next row in same section
        nextTag = currentSection * 1000 + (currentRow + 1)
    } else {
        // First row of next section (if exists)
        if currentSection < tableView.numberOfSections - 1 {
            nextTag = (currentSection + 1) * 1000 + 0
        }
    }
    
    if let tag = nextTag, let nextField = view.viewWithTag(tag) as? UITextField {
        nextField.becomeFirstResponder()
    } else {
        textField.resignFirstResponder()
    }
    
    return true
}

Important Notes: #

• Make sure your UITableViewDataSource methods (numberOfSections, numberOfRowsInSection) are correctly implemented—this is critical for calculating the next valid index path.
• Always set the delegate and tag/indexPath in cellForRowAt to avoid issues with cell reuse.
• If your table has a lot of rows per section, increase the multiplier in the tag approach (e.g., use 10000 instead of 1000) to prevent overlap.

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