Matriz rápida - Verifique se existe um índice

No Swift, existe alguma maneira de verificar se existe um índice em uma matriz sem que um erro fatal seja gerado?

Eu esperava poder fazer algo assim:

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
}

Mas eu entendo

erro fatal: índice da matriz fora do intervalo

Uma maneira elegante em Swift:

let isIndexValid = array.indices.contains(index)

Extensão do tipo:

extension Collection {

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

}

Usando isso, você obtém um valor opcional de volta ao adicionar a palavra-chave opcional ao seu índice, o que significa que seu programa não falha, mesmo que o índice esteja fora do intervalo. No seu exemplo:

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 verificar se o índice é menor que o tamanho da matriz:

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

Adicione um pouco de extensão de açúcar:

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"

Aprimora a legibilidade ao fazer if letcodificação de estilo em conjunto com matrizes

Você pode reescrever isso de uma maneira mais segura para verificar o tamanho da matriz e usar uma condicional ternária:

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

Extensão Swift 4:

Para mim, eu prefiro o 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
    }
}

Obrigado a @Benno Kress

Afirmando se existe um índice de matriz:

Essa metodologia é ótima se você não deseja adicionar açúcar de extensão:

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
    }

}

É trabalho para mim lidar com indexOutOfBounds .