Swift Array - Überprüfen Sie, ob ein Index vorhanden ist

Gibt es in Swift eine Möglichkeit zu überprüfen, ob ein Index in einem Array vorhanden ist, ohne dass ein schwerwiegender Fehler ausgelöst wird?

Ich hatte gehofft, ich könnte so etwas tun:

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
}

Aber ich verstehe

Schwerwiegender Fehler: Array-Index außerhalb des Bereichs

Ein eleganter Weg in Swift:

let isIndexValid = array.indices.contains(index)

Typerweiterung:

extension Collection {

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

}

Wenn Sie dies verwenden, erhalten Sie einen optionalen Wert zurück, wenn Sie das Schlüsselwort optional zu Ihrem Index hinzufügen. Dies bedeutet, dass Ihr Programm nicht abstürzt, selbst wenn der Index außerhalb des Bereichs liegt. In Ihrem Beispiel:

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
}

Überprüfen Sie einfach, ob der Index kleiner als die Arraygröße ist:

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

Fügen Sie etwas Verlängerungszucker hinzu:

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"

Verbessert die Lesbarkeit bei der Stilcodierung if letin Verbindung mit Arrays

Sie können dies sicherer umschreiben, um die Größe des Arrays zu überprüfen und eine ternäre Bedingung zu verwenden:

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

Swift 4 Erweiterung:

Für mich bevorzuge ich wie Methode.

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

Vielen Dank an @Benno Kress

Feststellen, ob ein Array-Index vorhanden ist:

Diese Methode eignet sich hervorragend, wenn Sie keinen Erweiterungszucker hinzufügen möchten:

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 ist Arbeit für mich, mit indexOutOfBounds umzugehen .