Swift Array: comprueba si existe un índice

En Swift, ¿hay alguna forma de verificar si existe un índice en una matriz sin que se genere un error fatal?

Esperaba poder hacer algo como esto:

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
}

Pero consigo

error fatal: índice de matriz fuera de rango

Una manera elegante en Swift:

let isIndexValid = array.indices.contains(index)

Tipo de extensión:

extension Collection {

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

}

Con esto, obtiene un valor opcional cuando agrega la palabra clave opcional a su índice, lo que significa que su programa no se bloquea incluso si el índice está fuera de rango. En tu ejemplo:

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
}

Simplemente verifique si el índice es menor que el tamaño de la matriz:

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

Agregue un poco de azúcar de extensión:

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"

Mejora la legibilidad al hacer if letcodificación de estilo junto con matrices

Puede reescribir esto de una manera más segura para verificar el tamaño de la matriz y usar un condicional ternario:

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

Extensión Swift 4:

Para mí prefiero como método.

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

Gracias a @Benno Kress

Afirmando si existe un índice de matriz:

Esta metodología es excelente si no desea agregar azúcar de extensión:

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
    }

}

Es trabajo para mí manejar indexOutOfBounds .