Swift Array - Vérifiez si un index existe

Dans Swift, existe-t-il un moyen de vérifier si un index existe dans un tableau sans qu'une erreur fatale ne soit générée?

J'espérais pouvoir faire quelque chose comme ça:

let arr: [String] = ["foo", "bar"]
let str: String? = arr[1]
if let str2 = arr[2] as String? {
    // this wouldn't run
    println(str2)
} else {
    // this would be run
}

Mais je reçois

erreur fatale: index de tableau hors limites

Une manière élégante dans Swift:

let isIndexValid = array.indices.contains(index)

Extension de type:

extension Collection {

    subscript(optional i: Index) -> Iterator.Element? {
        return self.indices.contains(i) ? self[i] : nil
    }

}

En utilisant cela, vous obtenez une valeur facultative lorsque vous ajoutez le mot-clé facultatif à votre index, ce qui signifie que votre programme ne plante pas même si l'index est hors de portée. Dans votre exemple:

let arr = ["foo", "bar"]
let str1 = arr[optional: 1] // --> str1 is now Optional("bar")
if let str2 = arr[optional: 2] {
    print(str2) // --> this still wouldn't run
} else {
    print("No string found at that index") // --> this would be printed
}

Vérifiez simplement si l'index est inférieur à la taille du tableau:

if 2 < arr.count {
    ...
} else {
    ...
}

Ajoutez du sucre d'extension:

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

if let item = ["a", "b", "c", "d"][safe: 3] { print(item) }//Output: "d"
//or with guard:
guard let anotherItem = ["a", "b", "c", "d"][safe: 3] else {return}
print(anotherItem) // "d"

Améliore la lisibilité lors du if letcodage de style en conjonction avec des tableaux

Vous pouvez réécrire ceci de manière plus sûre pour vérifier la taille du tableau et utiliser une condition ternaire:

if let str2 = (arr.count > 2 ? arr[2] : nil) as String?

Extension Swift 4:

Pour moi, je préfère comme méthode.

// MARK: - Extension Collection

extension Collection {

    /// Get at index object
    ///
    /// - Parameter index: Index of object
    /// - Returns: Element at index or nil
    func get(at index: Index) -> Iterator.Element? {
        return self.indices.contains(index) ? self[index] : nil
    }
}

Merci à @Benno Kress

Affirmer si un index de tableau existe:

Cette méthodologie est idéale si vous ne souhaitez pas ajouter de sucre d'extension:

let arr = [1,2,3]
if let fourthItem = (3 < arr.count ?  arr[3] : nil ) {
     Swift.print("fourthItem:  \(fourthItem)")
}else if let thirdItem = (2 < arr.count ?  arr[2] : nil) {
     Swift.print("thirdItem:  \(thirdItem)")
}
//Output: thirdItem: 3

extension Array {
    func isValidIndex(_ index : Int) -> Bool {
        return index < self.count
    }
}

let array = ["a","b","c","d"]

func testArrayIndex(_ index : Int) {

    guard array.isValidIndex(index) else {
        print("Handle array index Out of bounds here")
        return
    }

}

C'est un travail pour moi de gérer indexOutOfBounds .