If not let - in Swift

Question

c'è un modo per annullare "se let" in swift? Questo sembra sciocco a me:

if let type = json.type { 

    } else { 
     XCTFail("There is no type in the root element") 
    } 

non posso usare XCTAssertNotNil, perché json.type è un enum.

enum JSONDataTypes { 
    case Object 
    case Array 
    case Number 
    case String 
} 

Grazie mille

EDIT: si tratta di un:

var type: JSONDataTypes? = nil 

Answer 1

Swift 2.0 (Xcode 7) e poi avere la nuova dichiarazione guard, che funziona come un "se non lo è" - puoi vincolare condizionatamente una variabile nel resto dell'en ambito di chiusura, mantenendo il "buon percorso" nel codice il meno rientrato.

guard let type = json.type else { 
    XCTFail("There is no type in the root element") 
} 
// do something with `type` here 

La cattura di questo è che la clausola else di un guard deve uscire da quella portata (perché altrimenti ci si cade in codice dopo tale clausola, dove le variabili custoditi, come type sopra, sono legato). Quindi deve finire con qualcosa come return, break, continue o una funzione che è nota al compilatore di non tornare mai (cioè annotata @noreturn, come abort() ... Non ricordo se questa include XCTFail, ma dovrebbe (file a bug if it's not).

per i dettagli, consultare Early Exit in La Swift Programming Language.

---

per quanto riguarda la roba veramente vecchio ... non c'è forma negata di se-let in 1.x. Swift Ma dal momento che stai lavorando con XCTest in ogni caso, puoi solo ma ke testare la parte opzionale di un'espressione asserzione:

XCTAssert(json.type != nil, "There is no type in the root element") 

Answer 2

Ecco come si fa:

if json.type == nil { 
    // fail 
} 

Answer 3

Un'altra alternativa ho usato un paio di volte:

switch json.type 
{ 
    case .None: // ... 
    case .Some(.Object): // ... 
    case .Some(.Array): // ... 
    case .Some(.Number): // ... 
    case .Some(.String): // ... 
} 

Poiché la ? è in realtà Optional<T> che è un'enumerazione di per sé, come definito :

enum Optional<T> : Reflectable, NilLiteralConvertible 
{ 
    case None 
    case Some(T) 

    ... 
}