Ich habe verschiedene Bücher über den optionalen Typ erneut studiert, also werde ich darüber schreiben. Bitte beachten Sie, dass es schwer zu sehen sein kann, da ich das, was ich studiert habe, so veröffentlichen werde, wie es ist Es ist eher eine Verwendung als eine Verwendung, daher ist es besser, andere Artikel über die Verwendung zu lesen.
//Optional ist in enum definiert
enum Optional<Wrapped> {
case uone
case some(Wrapped)
}
let none = Optional<Int>.none
print(".none: \(String(describing: none))")
let some = Optional<Int>.some(1)
print(".some: \(String(describing: some))")
*Typinferenz
let some2 = Optional.some(1) // Optional<Int>
let none2: Int? = Optional.none // Optional<Int> nil
// .Einige können vom Typ abgeleitet werden.Keiner muss eingegeben werden. Fehler
var a: Int?
a = nil //durch keine wörtliche Zuordnung.Generiere keine
a = Optional(1) //Durch Initialisierer.Generieren Sie einige
a = 1 //Durch Wertzuweisung.Generieren Sie einige
let opInt: Int? = nil
let opString: String? = nil
print(type(of: opInt), String(describing: opInt))
print(type(of: opString), String(describing: opString))
// Optional<Int> nil
// Optional<String> nil
*Durch Initialisierer.Generieren Sie einige*
let opInt2 = Optional(1)
let opString2 = Optional("a")
print(type(of: opInt2), String(describing: opInt2))
print(type(of: opString2), String(describing: opString2))
// Optional<Int> Optional(1)
// Optional<String> Optional("a")
*Durch Wertzuweisung.Generieren Sie einige*
let opInt3: Int? = 1
print(type(of: opInt3), String(describing: opInt3))
// Optional<Int> Optional(1)
//Auspacken
// Optional<Wrapped>Weil der Typ möglicherweise keinen Wert hat
//Kann nicht wie umschlossene Variablen und Konstanten behandelt werden
// Int?Typ-zu-Typ-Operationen führen zu Fehlern
let aa: Int? = 1
let bb: Int? = 1
// aa +bb Dies ist ein Fehler
/*
Optional<Wrapped>So führen Sie eine Operation für einen Wrapped-Typwert aus, den ein Typwert hat
Optional<Wrapped>Es muss vom Typwert zum Wrapped-Typ extrahiert werden
Das Abrufen eines Wrapped-Typ-Werts wird als Unwrapping bezeichnet.
*/
*Wichtiger Platz
//Optionale Bindung
// ??Operator
//Erzwungenes Auspacken
*Optionale Bindung
/*
Optional für Bedingungen für bedingte Verzweigungen und sich wiederholende Anweisungen<Wrapped>Habe einen Typwert
Innerhalb des Zweigs, in dem das Vorhandensein des Werts garantiert, können Sie direkt auf den Wert vom Typ Wrapped zugreifen.
if-let Anweisung
if Konstantenname lassen Optional<Wrapped>Geben Sie value ein{
Anweisung ausgeführt, wenn der Wert vorhanden ist
}
*/
let optionalA = Optional("a") // String?Schimmel
if let a = optionalA {
print(type(of: a)) //Wird nur ausgeführt, wenn optionalA einen Wert hat
}
// String
* ??Operator
//Standardwert anzeigen, wenn kein Wert vorhanden ist
let optionalInt: Int? = 1
// let optionalInt: Int? =nil In diesem Fall wird 3 angezeigt
let int = optionalInt ?? 3 // 1
*Erzwungenes Auspacken
/*
Optional<Wrapped>So erzwingen Sie einen Wrapped-Wert aus einem Typ
Obligatorisch bedeutet, dass ein Ausführungsfehler auftritt, wenn der Wert nicht vorhanden ist.
!Verwenden Sie den Operator
*/
let num1: Int? = 1
let num2: Int? = 1
//Wie man erzwungenes Auspacken macht
num1! + num2! // 2
/*
Beim erzwungenen Auspacken werden Fälle ohne Wert ignoriert, sodass die Gefahr eines Fehlers besteht
Vermeiden Sie starke Beanspruchung
Wenn die Existenz des Wertes sehr klar ist,
Wenn der Wert nicht vorhanden ist, vermeiden Sie grundsätzlich die Verwendung, es sei denn, Sie möchten das Programm beenden
*/
*Optionale Kette
// Optional<Double>So greifen Sie vom Typ auf die Double isInfinite-Eigenschaft zu
//Optionale Bindung durchführen
let optionalDouble = Optional(1.0)
let optionalIsInfinite: Bool?
if let double = optionalDouble {
optionalIsInfinite = double.isInfinite
} else {
optionalIsInfinite = nil
}
print(String(describing: optionalIsInfinite))
/*
Mit optionalen Ketten können Sie auf Wrapped-Eigenschaften und -Methoden zugreifen, ohne sie zu entpacken.
Optional bei Verwendung der optionalen Kette<Wrapped>Nach den vier Jahreszeiten? gefolgt von
Beschreiben der Eigenschaften und Methodennamen von Wrapped-Typen
Optional<Wrapped>Wenn die Variable oder Konstante vom Typ Null ist?Nil wird zurückgegeben, ohne auf die unten beschriebenen Eigenschaften und Methoden zuzugreifen.
Original optional<Wrapped>Die Tatsache, dass der Typausdruck keinen Wert hat
Dies liegt daran, dass keine Eigenschaften oder Methoden für den Zugriff vorhanden sind und keine Werte zurückgegeben werden müssen.
Im folgenden Beispiel wird der obige Code mithilfe der optionalen Kette neu geschrieben. Das Ergebnis ist Bool.?Schimmel
*/
let opDouble = Optional(1.0)
let opIsInfinite = opDouble?.isInfinite
print(String(describing: opIsInfinite))
//Das folgende Beispiel enthält Aufrufe
// CountableRange<Int>?Gibt an, ob der Bereich der Typkonstante optionalRange den angegebenen Wert enthält
//Das Ergebnis ist Bool?Wert
let optionalRange = Optional(0..<10)
let containsSeven = optionalRange?.contains(7)
print(String(describing: containsSeven))
* map flatMap
//Methode zum Konvertieren von Werten ohne Auspacken
// Int?Führen Sie einen Abschluss aus, der den Wert für die Typkonstante num3 verdoppelt.
//Als Ergebnis Int?Typ Wert Optional(34)Habe erhalten
let num3 = Optional(17)
let num4 = num3.map { value in
value * 2
} // 34
type(of: num4) // Optional<Int>.Type
/*
Sie können die Karte auch verwenden, um sie in einen anderen Typ zu konvertieren
Int?Führt einen Abschluss aus, der Int für den Typ num5 in String konvertiert, was zu String führt?Erhalte 17
*/
let num5 = Optional(17)
let num6 = num5.map { val in
String(val)
} // "17"
type(of: num6)
// flat(Map
//Der Rückgabewert des Verschlusses ist optional
let num7 = Optional("17")
let num8 = num7.flatMap { val in
Int(val)
}
type(of: num8) // Optional<Int>.Type
//Punkt
/*
Es ist ein Punkt, an dem wir eine Operation ausführen, für die es ungewiss ist, ob ein Wert für eine Konstante zurückgegeben werden soll, deren Existenz ungewiss ist.
Wenn dies eine Karte anstelle einer flatMap ist
Das Endergebnis ist ein Double-Wrap-Typ Int??Wird
*/
let num9 = Optional("17")
let num10 = num9.map { val in
Int(val)
}
type(of: num10) // Optional<Optional<Int>>.Type
//FlatMap vereint diesen doppelt unsicheren Zustand zu einem.
//Implizites Auspacken
// Wrapped!Bezüglich
var aaa: String? = "aaa"
var bbb: String! = "bbb"
print(type(of: aaa))
print(type(of: bbb))
// Optional<String>
// Optional<String>
var ccc: String! = aaa
var ddd: String? = bbb
//Implizites Auspacken führt zu einem Fehler für Null
let eee: Int! = 1
eee + 1 //Die Berechnung ist auf die gleiche Weise wie beim Int-Typ möglich
// var fff: Int! = nil
// fff + 1 //Ein Laufzeitfehler tritt auf, weil kein Wert vorhanden ist
/*
Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value: file __lldb_expr_84/Optional.playground, line 224
Playground execution failed:
error: Execution was interrupted, reason: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0).
The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.
*/
Ich habe hart studiert, also habe ich vorerst einen Artikel geschrieben. Im Gegensatz zu anderen Artikeln ist die Qualität dieses Mal niedrig, daher bin ich dankbar, dass Sie sie gerade gelesen haben.