es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo arreglar la Complejidad Ciclomática? – RxDataSource RxSwift – SwiftLint

15 Jul, 2023 Programación

Me encontré con una advertencia como esta “Violación de Complejidad Ciclomática: La función debería tener una complejidad de 10 o menos: actualmente la complejidad es igual a 14 (cyclomatic_complexity)” cuando utilicé RxDataSource.

Mi estructura de código es así:

struct ItemDetailDataSource {
    typealias DataSource = RxTableViewSectionedReloadDataSource

static func dataSource() -> DataSource<itemdetailtableviewsection> {
    return .init(configureCell: { (dataSource, tableView, indexPath, _) -> UITableViewCell in

        switch dataSource[indexPath] {
        case .itemInfoTopItem(let info):
            guard let cell = tableView.dequeueReusableCell(withIdentifier: ConstantsForCell.infoTopTableViewCell,
                                                           for: indexPath)
                as? InfoTopTableViewCell else {
                    return UITableViewCell()
            }
            cell.configure(info)
            return cell
        case .itemHintItem(let hint):
        ...
        case .itemManaColdownItem(let manacd):
        case .itemNotesItem(let notes):
        case .itemAttribItem(let attrib):
        case .itemLoreItem(let lore):
        case .itemComponentsItem(let components):

¿Alguien puede ayudarme a solucionar esto? Muchas gracias.

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    El mensaje de advertencia sugiere que la complejidad de tu función es demasiado alta y debería reducirse a 10 o menos. La complejidad ciclomática se refiere al número de caminos que se pueden recorrer a través de una función. En tu caso, la instrucción switch es responsable de la alta complejidad.

    Para solucionar esta advertencia, puedes refactorizar tu código para reducir el número de casos en la instrucción switch. Una forma de hacer esto es mover la lógica de configuración de las celdas a sus respectivas clases de celdas. Esto hará que la instrucción switch sea mucho más corta y legible.

    Por ejemplo, puedes crear un protocolo base al que todas las clases de celdas deban conformar, con un método de configuración que reciba cada tipo de elemento:

    protocol ItemDetailConfigurable {
    func configure(_ item: ItemDetailTableViewItem)
}

    Luego, cada clase de celda puede implementar este protocolo y manejar su propia configuración:

    class InfoTopTableViewCell: UITableViewCell, ItemDetailConfigurable {
    // ...
    func configure(_ item: ItemDetailTableViewItem) {
        // manejar el caso .itemInfoTopItem
    }
}

// otras clases de celda con método de configuración

    En tu método de origen de datos, simplemente puedes llamar al método configure en la celda, sin la instrucción switch:

    static func dataSource() -> DataSource<itemdetailtableviewsection> {
    return .init(configureCell: { (dataSource, tableView, indexPath, item) -> UITableViewCell in
        let cell = tableView.dequeueReusableCell(withIdentifier: ConstantsForCell.infoTopTableViewCell, for: indexPath) as? ItemDetailConfigurable
        cell?.configure(item)
        return cell ?? UITableViewCell()
    })
}

    Esta refactorización no solo reducirá la complejidad ciclomática de tu función, sino que también hará tu código más modular y mantenible.

Comments are closed.