[xcode] 선택적 바인딩을 통해 Swift에서 안전 (경계 검사) 배열 조회?

이 동작을 정말로 원한다면 배열 대신 사전을 원하는 것처럼 냄새가납니다. 사전 반환 nil에 접근하는 열쇠가 어디에 배열의 키, 무엇이든 될 수 있기 때문에이 키가 사전에 존재 알고 더 힘들어 때문에 의미가있는 키가없는 경우 필수 :의 범위 0에 count. 그리고 그것은 당신이 할 수있는 범위, 반복하는 매우 일반적입니다 확신 루프의 각 반복에 실제 값을 가지고 있습니다.

이 방법으로 작동하지 않는 이유는 Swift 개발자가 선택한 디자인 선택이라고 생각합니다. 예를 들어 보자.

var fruits: [String] = ["Apple", "Banana", "Coconut"]
var str: String = "I ate a \( fruits[0] )"

배열을 사용하는 대부분의 경우처럼 인덱스가 존재한다는 것을 이미 알고 있다면이 코드가 좋습니다. 첨자에 액세스하는 가능성이 반환 할 경우, nil당신은 반환 형식 변경 의 Array의 subscript옵션으로 방법을. 코드가 다음과 같이 변경됩니다.

var fruits: [String] = ["Apple", "Banana", "Coconut"]
var str: String = "I ate a \( fruits[0]! )"
//                                     ^ Added

즉, 범위를 벗어난 인덱스에 거의 액세스 할 수 없기 때문에 배열을 반복하거나 알려진 인덱스로 다른 작업을 수행 할 때마다 선택 사항을 래핑 해제해야합니다. Swift 설계자는 범위를 벗어난 인덱스에 액세스 할 때 런타임 예외를 희생하면서 옵션의 언 래핑을 줄 이도록 선택했습니다. 그리고 nil데이터 어딘가에서 예상하지 못한 논리 오류보다 충돌이 바람직합니다 .

그리고 나는 그들에 동의합니다. 따라서 Array선택 사항이 아닌 값을 기대하는 모든 코드를 배열에서 분리하므로 기본 구현을 변경하지 않습니다 .

대신에 서브 클래스 Array를 작성하고 subscript옵션을 리턴하도록 대체 할 수 있습니다 . 또는 더 실제로 Array는이를 수행하는 비 첨자 방법으로 확장 할 수 있습니다 .

extension Array {

    // Safely lookup an index that might be out of bounds,
    // returning nil if it does not exist
    func get(index: Int) -> T? {
        if 0 <= index && index < count {
            return self[index]
        } else {
            return nil
        }
    }
}

var fruits: [String] = ["Apple", "Banana", "Coconut"]
if let fruit = fruits.get(1) {
    print("I ate a \( fruit )")
    // I ate a Banana
}

if let fruit = fruits.get(3) {
    print("I ate a \( fruit )")
    // never runs, get returned nil
}

스위프트 3 업데이트

func get(index: Int) ->T? 로 교체해야합니다 func get(index: Int) ->Element?

답변

myArray[safe: badIndex] = newValue

extension Collection {
    /// Returns the element at the specified index iff it is within bounds, otherwise nil.
    subscript(safe index: Index) -> Element? {
        return indices.contains(index) ? self[ index] : nil
    }
}

extension MutableCollection {
    subscript(safe index: Index) -> Element? {
        get {
            return indices.contains(index) ? self[ index] : nil
        }

        set(newValue) {
            if let newValue = newValue, indices.contains(index) {
                self[ index] = newValue
            }
        }
    }
}

extension Indexable {
    public subscript(safe safeIndex: Index) -> _Element? {
        return safeIndex.distanceTo(endIndex) > 0 ? self[safeIndex] : nil
    }
}

extension Array {
    subscript (safe index: Index) -> Element? {
        return 0 <= index && index < count ? self[index] : nil
    }
}

let itms: [Int?] = [0, nil]
let a = itms[safe: 0] // 0 : Int??
a ?? 5 // 0 : Int?
let b = itms[safe: 1] // nil : Int??
b ?? 5 // nil : Int?
let c = itms[safe: 2] // nil : Int??
c ?? 5 // 5 : Int?

extension Array {

    @warn_unused_result public func checkIndexForSafety(index: Int) -> SafeIndex? {

        if indices.contains(index) {

            // wrap index number in object, so can ensure type safety
            return SafeIndex(indexNumber: index)

        } else {
            return nil
        }
    }

    subscript(index:SafeIndex) -> Element {

        get {
            return self[index.indexNumber]
        }

        set {
            self[index.indexNumber] = newValue
        }
    }

    // second version of same subscript, but with different method signature, allowing user to highlight using safe index
    subscript(safeIndex index:SafeIndex) -> Element {

        get {
            return self[index.indexNumber]
        }

        set {
            self[index.indexNumber] = newValue
        }
    }

}

public class SafeIndex {

    var indexNumber:Int

    init(indexNumber:Int){
        self.indexNumber = indexNumber
    }
}

extension Array {

    func item(at index: Int) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}