Swift Array: controlla se esiste un indice

In Swift, c'è un modo per verificare se esiste un indice in un array senza che venga generato un errore fatale?

Speravo di poter fare qualcosa del genere:

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
}

Ma capisco

errore irreversibile: indice di array fuori intervallo

Un modo elegante in Swift:

let isIndexValid = array.indices.contains(index)

Estensione del tipo:

extension Collection {

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

}

Usando questo ottieni un valore opzionale quando aggiungi la parola chiave opzionale al tuo indice, il che significa che il tuo programma non si arresta in modo anomalo anche se l'indice non è compreso nell'intervallo. Nel tuo esempio:

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
}

Basta controllare se l'indice è inferiore alla dimensione dell'array:

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

Aggiungi un po 'di zucchero di estensione:

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"

Migliora la leggibilità quando si esegue la if letcodifica di stile in combinazione con le matrici

È possibile riscriverlo in un modo più sicuro per verificare le dimensioni dell'array e utilizzare un condizionale ternario:

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

Estensione Swift 4:

Per me preferisco il metodo simile.

// 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
    }
}

Grazie a @Benno Kress

Asserire se esiste un indice di array:

Questa metodologia è ottima se non si desidera aggiungere l'estensione di zucchero:

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
    }

}

Per me è compito gestire indexOutOfBounds .