Optionale Typen in Swift

1. Das Konzept des optionalen Typs

Der optionale Typ wird verwendet, um zu sagen: „Es gibt einen Wert, der gleich x ist, oder es gibt überhaupt keinen Wert.“ Wenn wir auf den optionalen Typ stoßen, wissen wir natürlich, dass der Wert hier Null sein kann, und wir müssen vorsichtig damit umgehen.

2. Implementierung des optionalen Typs

var optionalInteger: Int?
//或者
var optionalInteger: Int!

In? Und! Alle sind optionale Syntax

3. Die Essenz des optionalen Typs

Optional ist eigentlich eine Aufzählung (streng genommen: Es sollte ein abstrakter Typ höherer Ordnung sein, der auf Aufzählung und Generika basiert), die None bzw. Some(T) sind. Wenn der optionale Typ Null ist, wird der Fall None getroffen.

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

Wenn Sie den Fall von Some(T) treffen, erhalten Sie einen „verpackten“ Wert (einen umschlossenen Wert). Wenn Sie den tatsächlichen Wert erhalten möchten, müssen Sie ihn „entpacken“, andernfalls erhalten Sie den optionalen Wert ).

4. Anwendung des optionalen Typs (Auspacken)

Optionale Bindung

Optionale Bindungen können in if- und while-Anweisungen verwendet werden, um optionale Werte auszuwerten und den Wert einer Konstanten oder Variablen zuzuweisen.

Sie können die optionale Bindung verwenden, um zu bestimmen, ob eine Option einen Wert enthält.

Wenn es enthalten ist, wird es automatisch entpackt, weist den Wert einer temporären Konstante (let) oder Variablen (var) zu und gibt true zurück, andernfalls gibt es false zurück.

Grundlegende Syntax:

if let constantName = someOptional {
    statements
}

Beispiel:

var myString:String?
myString = "Hello, Swift!"
if let yourString = myString {
   print("myString 值为 - \(yourString)")
}else{
   print("myString 值为 nil")
}

Auspacken erzwingen

Optional ist eine Verpackungsschicht für andere Arten. Sie kann als Karton verstanden werden

• Wenn Null, dann handelt es sich um eine leere Box
• Wenn es nicht Null ist, enthält die Box Daten vom gepackten Typ.
• Wenn Sie die umschlossenen Daten aus Optional herausnehmen möchten, müssen Sie ein Ausrufezeichen verwenden! Zwangsauspacken durchführen
• Wenn Sie ein Optional mit dem Wert Null zwangsweise entpacken, tritt ein Laufzeitfehler auf.

var myString:String?
myString = "Hello, world!"
if myString != nil {
   // 强制解析
   print( myString! )
}else{
   print("myString 值为 nil")
}

Optionale Typen können anderen Typen nicht direkt zugewiesen werden. Beispielsweise kann Int? nicht direkt Variablen vom Typ Int zugewiesen werden. Sie müssen zuerst entpackt werden. Optionale Typen mit dem Wert Null können nicht entpackt werden. 

var text: String? = "abc"
print(text)     //输出结果为Optional("abc")
print(text!)    //输出结果为abc
var a:String
a = text!       //强制解包

implizites Auspacken

Implizites Entpacken wird direkt beim Definieren hinzugefügt!

Für Variablen, die in viewDidLoad initialisiert werden, können sie direkt als var str: String! definiert werden, was als implizites Entpacken bezeichnet wird. Sie müssen auch! zum Entpacken hinzufügen, wenn Sie Vorgänge ausführen.

let text:String! = "abc"    //text的类型还是Optional
print(text)    //输出结果为Optional("abc")
var a:String
a = text    //隐式类型转换
print(a)    //输出结果为abc

Der Unterschied zwischen ! und ?

? Nutzungsszenarien:

• Deklarieren Sie eine optionale Wertvariable
• Beim Betrieb mit optionalen Werten wird damit bestimmt, ob auf nachfolgende Vorgänge reagiert werden kann.

! Nutzungsszenarien:

• Erzwingen Sie das Entpacken optionaler Werte
• Deklarieren Sie implizite Entpackvariablen, die im Allgemeinen für Attribute in Klassen verwendet werden