Quando usar dequeueReusableCellWithIdentifier vs dequeueReusableCellWithIdentifier: forIndexPath

Existem duas sobrecargas para o dequeueReusableCellWithIdentifier e estou tentando determinar quando devo usar um vs o outro?

Os documentos da apple sobre a função forIndexPath afirma: "Este método usa o caminho do índice para executar configurações adicionais com base na posição da célula na exibição da tabela".

Eu não tenho certeza de como interpretar isso?

A diferença mais importante é que a forIndexPath:versão declara (trava) se você não registrou uma classe ou ponta para o identificador. A forIndexPath:versão mais antiga (não ) retorna nilnesse caso.

Você registra uma classe para um identificador enviando registerClass:forCellReuseIdentifier:para a exibição de tabela. Você registra uma ponta para um identificador enviando registerNib:forCellReuseIdentifier:para a visualização de tabela.

Se você criar sua exibição de tabela e seus protótipos de célula em um storyboard, o carregador de storyboard cuidará do registro dos protótipos de célula que você definiu no storyboard.

Sessão 200 - O que há de novo no Cocoa Touch da WWDC 2012 discute a forIndexPath:versão (então nova) a partir dos 8m30s. Ele diz que “você sempre obterá uma célula inicializada” (sem mencionar que ela travará se você não registrar uma classe ou ponta).

O vídeo também diz que "será do tamanho certo para esse caminho de índice". Presumivelmente, isso significa que ele definirá o tamanho da célula antes de devolvê-la, examinando a largura da visualização da tabela e chamando o tableView:heightForRowAtIndexPath:método do seu representante (se definido). É por isso que ele precisa do caminho do índice.

dequeueReusableCellWithIdentifier:forIndexPath:vai sempre retornar uma célula. Ele reutiliza as células existentes ou cria uma nova e retorna se não houver células.

Enquanto, o tradicional dequeueReusableCellWithIdentifier:retornará uma célula, se existir, ou seja, se houver uma célula que possa ser reutilizada, ela retornará e, caso contrário, ela retornará nula. Então você teria que escrever uma condição para verificar o nilvalor também.

Para responder à sua pergunta, use dequeueReusableCellWithIdentifier:quando desejar oferecer suporte ao iOS 5 e versões inferiores, pois ele dequeueReusableCellWithIdentifier:forIndexPathestá disponível apenas no iOS 6 ou superior

Referência: https://developer.apple.com/library/ios/documentation/uikit/reference/UITableView_Class/Reference/Reference.html#//apple_ref/occ/instm/UITableView/dequeueReusableCellWithIdentifier:forIndexPath :

Eu nunca entendi por que a Apple criou o método mais recente, dequeueReusableCellWithIdentifier: forIndexPath :. A documentação deles não está completa e é um tanto enganadora. A única diferença que eu consegui discernir entre os dois métodos é que esse método mais antigo pode retornar nulo, se não encontrar uma célula com o identificador passado, enquanto o método mais novo trava, se não puder retornar. uma célula. É garantido que ambos os métodos retornam uma célula, se você definiu o identificador corretamente, e transformam a célula em um storyboard. Também é garantido que ambos os métodos retornem uma célula se você registrar uma classe ou xib e criar sua célula no código ou em um arquivo xib.

Como diminutivo:

dequeueReusableCell(withIdentifier, for)só funciona com células protótipo. Se você tentar usá-lo quando a célula protótipo estiver ausente, ele travará o aplicativo.

Hollemans M. 2016, Capítulo 2 Checklist, IOS Apprentice (5ª Edição). pp: 156.

Eu recomendaria usar os dois se você estiver usando conteúdo gerado dinamicamente. Caso contrário, seu aplicativo poderá falhar inesperadamente. Você pode implementar sua própria função para recuperar uma célula reutilizável opcional. Se for, nilvocê deve retornar uma célula vazia que não é visível:

Swift 3

// Extensions to UITableView
extension UITableView
{
    // returns nil, if identifier does not exist. 
    // Otherwise it returns a configured cell for the given index path
    open func tryDequeueReusableCell (
        withIdentifier identifier: String, 
        for indexPath: IndexPath) -> UITableViewCell?
    {
        let cell = self.dequeueReusableCell(withIdentifier: identifier)
        if cell != nil {
            return self.dequeueReusableCell(withIdentifier: identifier, for: indexPath)
        }  
        return nil
    }
}

E a extensão para retornar uma célula vazia:

// Extension to UITableViewCell
extension UITableViewCell
{
    // Generates an empty table cell that is not visible
    class func empty() -> UITableViewCell
    {
        let emptyCell = UITableViewCell(frame:CGRect(x:0, y:0, width:0, height:0))
        emptyCell.backgroundColor = UIColor.clear
        return emptyCell
    }
}

Um exemplo completo de como usá-lo:

import Foundation
import UIKit

// A protocol is used to identify if we can configure
// a cell with CellData
protocol ConfigureAbleWithCellData
{
    func configure(_ data: CellData)
}

class MyCustomTableViewCell :
    UITableViewCell,
    ConfigureAbleWithCellData
{
    @IBOutlet weak var title:UILabel! = nil
    func configure(_ data: CellData)
    {
        self.title.text = data.title
    }
}

// This actually holds the data for one cell
struct CellData
{
    var title:String = ""
    var reusableId:String = ""
}

class CosmoConverterUnitTableViewController:
    UIViewController,
    UITableViewDelegate,
    UITableViewDataSource
{
    // Storage
    var data = Array<Array<CellData>>()

    func loadData()
    {
        var section1:[CellData] = []
        var section2:[CellData] = []

        section1.append(CellData(title:"Foo", reusableId:"cellType1"))
        section2.append(CellData(title:"Bar", reusableId:"cellType2"))

        data.append(section1)
        data.append(section2)
    }

    func tableView(_ tableView: UITableView,
                   numberOfRowsInSection section: Int) -> Int
    {
        return data[section].count
    }

    public func numberOfSections(in tableView: UITableView) -> Int
    {
        return data.count
    }

    func tableView(
        _ tableView: UITableView,
        cellForRowAt indexPath: IndexPath) -> UITableViewCell {

        guard
            indexPath.row < data[indexPath.section].count
            else
        {
            fatalError("this can't be")
        }

        let cellData = data[indexPath.section][indexPath.row]

        if let cell = tableView.tryDequeueReusableCell(
            withIdentifier: cellData.reusableId,
            for: indexPath)
        {
            if let configurableCell = cell as? ConfigureAbleWithCellData
            {
                configurableCell.configure(cellData)
            }
            else
            {
                // cell is not of type ConfigureAbleWithCellData
                // so we cant configure it.
            }
            return cell
        }
        // id does not exist
        return UITableViewCell.empty()
    }
}