Comment puis-je attraper “Index out of range” dans Swift?

Je voudrais vraiment utiliser un plus classique simple bloc try catch dans mon code Swift mais je ne peux pas trouver quelque chose qui le fait.

J'ai juste besoin de:

try {
//some code that causes a crash.
}
catch {
//okay well that crashed, so lets ignore this block and move on.
}

Voici mon dilemme, lorsque le TableView est rechargé avec de nouvelles données, de l'information est toujours l'emplacement dans la mémoire RAM qui appelle didEndDisplayingCell sur un tableView avec un fraîchement vide de la source de données à l'incident.

Donc j'ai souvent jeté l'exception Index out of range

J'ai essayé ceci:

func tableView(tableView: UITableView, didEndDisplayingCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {

    do {
        let imageMessageBody = msgSections[indexPath.section].msg[indexPath.row] as? ImageMessageBody
        let cell = tableView.dequeueReusableCellWithIdentifier("ImageUploadCell", forIndexPath: indexPath) as! ImageCell
        cell.willEndDisplayingCell()
    } catch {
        print("Swift try catch is confusing...")
    }
}

J'ai aussi essayé ceci:

func tableView(tableView: UITableView, didEndDisplayingCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
    print(indexPath.section)
    print(indexPath.row)

    if msgSections.count != 0 {
        if let msg = msgSections[indexPath.section].msg[indexPath.row] as? ImageMessageBody {
            let cell = tableView.dequeueReusableCellWithIdentifier("ImageUploadCell", forIndexPath: indexPath) as! ImageCell
            cell.willEndDisplayingCell()
        }
    }
}

C'est une très faible priorité de bloc de code, et j'ai perdu beaucoup de temps avec l'essai et l'erreur de déterminer quelles gestionnaire d'erreurs intégrées dans swift œuvres de ce qui semble être extrêmement unique situations quand j'ai des tonnes de scénarios comme celui-ci où le code peut se bloquer et il n'aura pas d'effet sur l'expérience de l'utilisateur.

En bref, je n'ai pas besoin de rien de fantaisie, mais Swift semble avoir très spécifiques des gestionnaires d'erreur qui diffèrent selon si j'obtiens une valeur à partir d'une des fonctions de valeur de retour ou d'obtenir une valeur à partir d'un tableau d'index qui n'existe pas.

Est-il un simple try catch sur Swift, comme tout autre langage de programmation populaire?

developer.apple.com/library/ios/documentation/Swift/Conceptual/...
Il semble que vous essayez de résoudre le mauvais problème. Vous devez être résoudre le problème du pourquoi didEndDisplayCell est appelée sur les anciennes données après avoir rechargé la vue de la table. Qui n'a pas de sens. Pourquoi cela devrait-il se produire? Êtes-vous la mise à jour de la table de données de la vue sur un thread d'arrière-plan? Que serait un problème possible.
Généralement, jamais appel délégué méthodes contenant did, will et should par vous-même. Ils sont appelés par le cadre.
vous avez à gérer cela en vérifiant le comte de tableau avant de acessing par l'index.
Avez-vous compris pourquoi est-ce qui se passe dans votre cas?

OriginalL'auteur Matt Andrzejczuk | 2016-05-14

  1. 33

    Comme suggéré dans les commentaires et les autres réponses, il est préférable d'éviter ce genre de situations. Cependant, dans certains cas, vous pouvez vérifier si un élément existe dans un tableau et si c'est le retour en toute sécurité. Pour cela, vous pouvez utiliser le Tableau ci-dessous extension en toute sécurité pour le retour d'un élément de tableau.

    Swift 3

    extension Collection where Indices.Iterator.Element == Index {
    subscript (safe index: Index) -> Generator.Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

    Swift 2

    extension Array {
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}
    • De cette façon vous aurez ne jamais frapper Index out of range
    • Vous aurez à vérifier si l'élément est nil

    reportez-vous cette question pour plus d'

    Essayer le Swift3 code dans une aire de Jeux dans Xcode 8.3.2 conduit encore à une
    "crash" quand je, ne laissez ar = [1,3,4], puis laissez = v ar[5]. Pourquoi? – Thomas
    Tempelmann 17 Mai à 17:40

    Vous devez utiliser notre personnalisés indice ainsi, au lieu de let v = ar[5], il wll let v = ar[safe: 5].

    Défaut d'obtenir la valeur de la matrice.

    let boo = foo[index]

    Ajouter l'utilisation de la mesure d'indice.

    let boo = fee[safe: index]

//And we can warp the result using guard to keep the code going without throwing the exception.
guard let boo = foo[safe: index] else {
  return
}
    Je souhaite que ce était le comportement par défaut
    pas fonctionné pour moi. Pouvez-vous expliquer comment cela fonctionne et qu'est-ce que ~indices~ dans ce
    Cela introduit des options à des contextes lorsqu'aucune options ne devraient pas être nécessaires. La meilleure solution est de laisser votre app crash. L'indexation en dehors des limites est un signe de programmeur d'erreur. Vous ne devriez pas ignorer ce signe ou d'essayer de l'avaler avec une en option. Simplement l'éviter.
    Hors limite d'index ne peut pas être due à une erreur de programmation. Par exemple, vous travaillez avec des données dynamiques que vous en tant que programmeur n'avez aucun contrôle sur. La langue doit sauvegarder le programme de jamais de jamais de fin dans un fœtus erreur d'exécution. C'est un signe de mauvaise langue de la conception et de la petite enfance de Swift par rapport à d'autres langues. Espérons que cela est changé dans les versions futures.
    Essayer le Swift3 code dans une aire de Jeux dans Xcode 8.3.2 conduit encore à un "crash" quand je fais let ar = [1,3,4], puis let v = ar[5]. Pourquoi?

    OriginalL'auteur Penkey Suresh

  2. 24

    Swift Erreur De Manipulation (do/try/catch) est pas la solution à des exceptions d'exécution comme "index out of range".

    Une exception d'exécution (vous pouvez également voir ces appelés piège, erreur fatale, échec d'assertion, etc.) est un signe de programmeur d'erreur. Sauf dans -Ounchecked construit, Swift généralement des garanties que ces crash votre programme, plutôt que de continuer à exécuter dans un mauvais/état indéfini. Ces sortes d'accidents peuvent survenir à partir de la force d'ôter avec !, implicite déballage, l'abus de unowned références, les opérations sur entiers/conversions qui débordent, fatalError()s et precondition()s et assert()s, etc. (Et, malheureusement, Objective-C exceptions).

    La solution est tout simplement de éviter ces situations. Dans votre cas, vérifiez les limites du tableau:

    if indexPath.section < msgSections.count && indexPath.row < msgSections[indexPath.section].msg.count {
    let msg = msgSections[indexPath.section].msg[indexPath.row]
    //...
}

    (Ou, comme rmaddy dit dans les commentaires d'une enquête sur pourquoi ce problème est survenu! Il ne devrait pas se produire du tout.)

    OriginalL'auteur jtbandes

  3. 6

    Swift 4:

    extension Collection where Indices.Iterator.Element == Index {
    subscript (exist index: Index) -> Iterator.Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

    Utilisation:

    var index :Int = 6 //or whatever number you need
if let _ = myArray[exist: index] {
   //do stuff
}

    ou

    var index :Int = 6 //or whatever number you need
guard let _ = myArray[exist: index] else { return }

    OriginalL'auteur Alessandro Ornano

  4. 1

    Vous pouvez essayer une approche différente pour cette. Vais sûrement travailler!

    if msgSections != nil {
    for msg in msgSections[indexPath.section] {
        if msgSections[indexPath.section].index(of: msg) == indexPath.row {
            (Code)
        }
}

    OriginalL'auteur Nimish Sharma