rapido: qual è il modificatore del tipo forzato (!) Per

Question

La rapida documentazione spiega lo scopo di! operatore unboxing sui tipi opzionali,

var optionalString : String? = "optional" 
var regularString: String = optionalString! 

ma hanno usato su se stessi tipo definizioni (String!), senza una spiegazione esplicita che posso trovare.

Esempio:

func takesBang(value:String!) -> String { 
    if !value { 
     return "nil value, without the safe syntax" 
    } 

    return "This works" 
} 

var unsafe:String! 
takesBang(unsafe) // yields "nil value, without the safe syntax" 

The String! type non impone un unboxing del tipo opzionale, ma sembra solo rimuovere la necessità della sintassi opzionale (?.). Apple usa questo nei propri esempi, ma sembra negare solo i meccanismi di sicurezza (puntatore) opzionali.

Qualcuno può spiegare lo scopo/la motivazione? Questo in genere non è sicuro in quanto il chiamante non dovrà controllare o almeno pensare al loro valore.

Answer 1

Si scopre che questo era solo una svista da parte di Apple, sono stati classi di revisione e aggiornamento dei tipi di ritorno dal Beta 5.

Dai Beta 6 note di rilascio:

"Un gran numero di API della Fondazione sono stati oggetto di revisione contabile per facoltativo conformità, la rimozione di un numero significativo di implicitamente Unwrapped optional dalle loro interfacce. Questo chiarisce il nullability di loro proprietà e argomenti/valori di ritorno dei loro metodi. Questo è uno sforzo continuo dalla versione beta 5. "

Answer 2

Generalmente non è sicuro, ma viene utilizzato per API Objective-C importate, che sono già non sicure in questo modo e non forniscono informazioni sufficienti per decidere se devono essere facoltative o non opzionali.

Nelle API non importate, non mi aspetto che venga utilizzato molto.

Answer 3

Il di riferimento di afferma che sia, ? come anche !, quando viene utilizzato su var dichiarazioni sono solo zucchero sintattico (nel senso che vengono sostituiti dal compilatore durante parsing). Si mappano rispettivamente a Optional<T> (?) E ImplicitlyUnwrappedOptional<T> (!).

Mentre è necessario utilizzare la sintassi if let maybeNil = someVar? { ... } per le variabili di tipo Optional<T>, non è necessario eseguire questa operazione con gli optionals implicitamente da scartare (come già implica il nome). Come già menzionato nella locandina https://stackoverflow.com/a/24071003/1599345, gli optionals implicitamente non confezionati devono essere utilizzati con le API legacy Objective-C, poiché questi non forniscono informazioni sufficienti per Swift.

Così come un breve riassunto:

var foo : SomeType? // should be read as var foo : Optional<SomeType> 
var bar : SomeType! // should be read as var bar : ImplicitlyUnwrappedOptional<SomeType> 

L'uso di ? e ! quando si lavora con valori attuali delle variabili è in realtà una mappatura che può essere letto in questo modo, analoga alle dichiarazioni di cui sopra:

foo?.somemethod() // if let maybeFoo = foo { maybeFoo.somemethod() } 

foo!.somemethod() /* # Yeah I know for sure, that this is NOT nil ever ever… just call `somemethod` and kill me at runtime if it doesn't work out.