Rozpakowuję dwie wartości ze słownika i przed ich użyciem muszę je rzutować i przetestować pod kątem odpowiedniego typu. Oto, co wymyśliłem:

var latitude : AnyObject! = imageDictionary["latitude"]
var longitude : AnyObject! = imageDictionary["longitude"]

if let latitudeDouble = latitude as? Double  {
   if let longitudeDouble = longitude as? Double {
       // do stuff here
   }
}

Ale chciałbym spakować te dwa, jeśli pozwolę zapytaniom w jedno. Żeby coś takiego:

if let latitudeDouble = latitude as? Double, longitudeDouble = longitude as? Double {
    // do stuff here
}

Ta składnia nie działa, więc zastanawiałem się, czy jest na to piękny sposób.

Aktualizacja dla Swift 3:

W Swift 3 będą działać następujące elementy:

if let latitudeDouble = latitude as? Double, let longitudeDouble = longitude as? Double {
    // latitudeDouble and longitudeDouble are non-optional in here
}

Pamiętaj tylko, że jeśli jedno z prób opcjonalnego powiązania nie powiedzie się, kod wewnątrz if-letbloku nie zostanie wykonany.

Uwaga: nie wszystkie klauzule muszą być klauzulami „let”, możesz mieć dowolną serię sprawdzeń logicznych oddzielonych przecinkami.

Na przykład:

if let latitudeDouble = latitude as? Double, importantThing == true {
    // latitudeDouble is non-optional in here and importantThing is true
}

Swift 1.2:

Apple mogło przeczytać Twoje pytanie, ponieważ Twój oczekiwany kod kompiluje się poprawnie w Swift 1.2 (dziś w wersji beta):

if let latitudeDouble = latitude as? Double, longitudeDouble = longitude as? Double {
    // do stuff here
}

Swift 1.1 i starsze:

Oto dobra wiadomość - możesz to zrobić całkowicie. Instrukcja switch na krotce twoich dwóch wartości może używać dopasowania do wzorca, aby rzutować obie na Doublew tym samym czasie:

var latitude: Any! = imageDictionary["latitude"]
var longitude: Any! = imageDictionary["longitude"]

switch (latitude, longitude) {
case let (lat as Double, long as Double):
    println("lat: \(lat), long: \(long)")
default:
    println("Couldn't understand latitude or longitude as Double")
}

Aktualizacja: ta wersja kodu działa teraz poprawnie.

Dzięki Swift 3 możesz użyć opcjonalnego łączenia łańcuchowego, instrukcji przełączania lub opcjonalnego wzorca w celu rozwiązania problemu.

1. Używanie if let(opcjonalne wiązanie / opcjonalne tworzenie łańcuchów)

Język Swift Programming Language stwierdza o opcjonalnym łańcuchowaniu:

Wiele zapytań może być połączonych ze sobą, a cały łańcuch kończy się niepowodzeniem, jeśli jakiekolwiek ogniwo w łańcuchu jest zerowe.

Dlatego w najprostszym przypadku możesz użyć następującego wzorca, aby użyć wielu zapytań w opcjonalnej operacji tworzenia łańcucha:

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

if let latitude = latitude as? Double, let longitude = longitude as? Double {
    print(latitude, longitude)
}

// prints: 2.0 10.0

2. Używanie krotek i wiązania wartości w instrukcji switch

Jako alternatywa dla prostego opcjonalnego łączenia łańcuchowego, instrukcja switch może oferować drobnoziarniste rozwiązanie, gdy jest używana z krotkami i wiązaniem wartości:

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

switch (latitude, longitude) {
case let (Optional.some(latitude as Double), Optional.some(longitude as Double)):
    print(latitude, longitude)
default:
    break
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

switch (latitude, longitude) {
case let (latitude as Double, longitude as Double):
    print(latitude, longitude)
default:
    break
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

switch (latitude as? Double, longitude as? Double) {
case let (.some(latitude), .some(longitude)):
    print(latitude, longitude)
default:
    break
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

switch (latitude as? Double, longitude as? Double) {
case let (latitude?, longitude?):
    print(latitude, longitude)
default:
    break
}

// prints: 2.0 10.0

3. Używanie krotek z if case(opcjonalny wzorzec)

if case( wzorzec opcjonalny ) zapewnia wygodny sposób rozpakowania wartości opcjonalnego wyliczenia. Możesz go używać z krotkami, aby wykonać opcjonalne łańcuchowanie z wieloma zapytaniami:

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

if case let (.some(latitude as Double), .some(longitude as Double)) = (latitude, longitude) {
    print(latitude, longitude)
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

if case let (latitude as Double, longitude as Double) = (latitude, longitude) {
    print(latitude, longitude)
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

if case let (.some(latitude), .some(longitude)) = (latitude as? Double, longitude as? Double) {
    print(latitude, longitude)
}

// prints: 2.0 10.0

let dict = ["latitude": 2.0 as AnyObject?, "longitude": 10.0 as AnyObject?]
let latitude = dict["latitude"]
let longitude = dict["longitude"]

if case let (latitude?, longitude?) = (latitude as? Double, longitude as? Double) {
    print(latitude, longitude)
}

// prints: 2.0 10.0

Swift 3.0

if let latitudeDouble = latitude as? Double, let longitudeDouble = longitude as? Double {
    // do stuff here
}