J'ai réétudié divers livres sur le type facultatif, je vais donc en parler. Veuillez noter que cela peut être difficile à voir car je publierai ce que j'ai étudié tel quel C'est plus une utilisation qu'une utilisation, il est donc préférable de lire d'autres articles sur la façon de l'utiliser.
--Un type qui représente une valeur ou un vide
//Facultatif est défini dans enum
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))")
*Inférence de type
let some2 = Optional.some(1) // Optional<Int>
let none2: Int? = Optional.none // Optional<Int> nil
// .certains peuvent être de type inféré.aucun ne doit être tapé Erreur
var a: Int?
a = nil //par affectation littérale nulle.Générer aucun
a = Optional(1) //Par initialiseur.Générer
a = 1 //Par attribution de valeur.Générer
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
*Par initialiseur.Générer*
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")
*Par attribution de valeur.Générer*
let opInt3: Int? = 1
print(type(of: opInt3), String(describing: opInt3))
// Optional<Int> Optional(1)
//Déballer
// Optional<Wrapped>Parce que le type peut ne pas avoir de valeur
//Ne peut pas être traité de la même manière que les variables et constantes de type enveloppé
// Int?Les opérations de type à type entraînent une erreur
let aa: Int? = 1
let bb: Int? = 1
// aa +bb Ceci est une erreur
/*
Optional<Wrapped>Pour effectuer une opération sur une valeur de type enveloppé qu'une valeur de type a
Optional<Wrapped>Besoin d'extraire de la valeur de type au type enveloppé
L'opération de récupération d'une valeur de type Wrapped est appelée déroulage.
*/
*Place importante
//Reliure facultative
// ??opérateur
//Déballage forcé
*Reliure facultative
/*
Facultatif pour les conditions de branchement conditionnel et d'instructions répétitives<Wrapped>Avoir une valeur de type
Au sein de la branche où l'existence de la valeur garantit, vous pouvez accéder directement à la valeur de type Wrapped.
if-let déclaration
if let nom de constante Facultatif<Wrapped>Valeur de type{
Instruction exécutée si la valeur existe
}
*/
let optionalA = Optional("a") // String?Moule
if let a = optionalA {
print(type(of: a)) //Uniquement exécuté lorsque optionalA a une valeur
}
// String
* ??opérateur
//Afficher la valeur par défaut si la valeur n'existe pas
let optionalInt: Int? = 1
// let optionalInt: Int? =nil Dans ce cas, 3 s'affiche
let int = optionalInt ?? 3 // 1
*Déballage forcé
/*
Optional<Wrapped>Comment forcer une valeur enveloppée à partir d'un type
Obligatoire signifie que si la valeur n'existe pas, une erreur d'exécution se produira.
!Utiliser l'opérateur
*/
let num1: Int? = 1
let num2: Int? = 1
//Comment faire un déballage forcé
num1! + num2! // 2
/*
Le déballage forcé ignore les cas sans valeur, il y a donc un risque d'erreur
Évitez une utilisation intensive
Lorsque l'existence de la valeur est très claire,
Lorsque la valeur n'existe pas, évitez essentiellement de l'utiliser sauf là où vous souhaitez terminer le programme
*/
*Chaîne en option
// Optional<Double>Pour accéder à la propriété Double isInfinite à partir de type
//Faire une liaison facultative
let optionalDouble = Optional(1.0)
let optionalIsInfinite: Bool?
if let double = optionalDouble {
optionalIsInfinite = double.isInfinite
} else {
optionalIsInfinite = nil
}
print(String(describing: optionalIsInfinite))
/*
Les chaînes optionnelles vous permettent d'accéder aux propriétés et méthodes Wrapped sans déballer.
Facultatif lors de l'utilisation de la chaîne en option<Wrapped>Après les quatre saisons? Suivi par
Décrire les propriétés de type enveloppé et les noms de méthode
Optional<Wrapped>Si la variable ou constante de type est nulle?Nil est renvoyé sans accéder aux propriétés et méthodes décrites ci-dessous.
Original facultatif<Wrapped>Le fait que l'expression de type n'a pas de valeur
C'est parce qu'il n'y a pas de propriétés ou de méthodes auxquelles accéder et qu'il n'y a aucune valeur à renvoyer.
Dans l'exemple ci-dessous, le code ci-dessus est réécrit à l'aide de la chaîne facultative. Le résultat est Bool.?Moule
*/
let opDouble = Optional(1.0)
let opIsInfinite = opDouble?.isInfinite
print(String(describing: opIsInfinite))
//L'exemple ci-dessous les appels contient
// CountableRange<Int>?Indique si la plage du type constant optionalRange contient la valeur spécifiée
//Le résultat du jugement est Bool?valeur
let optionalRange = Optional(0..<10)
let containsSeven = optionalRange?.contains(7)
print(String(describing: containsSeven))
* map flatMap
//Méthode pour convertir la valeur sans déballer
// Int?Exécuter une fermeture qui double la valeur du type constante num3,
//En conséquence Int?Valeur de type Facultatif(34)Ont reçu
let num3 = Optional(17)
let num4 = num3.map { value in
value * 2
} // 34
type(of: num4) // Optional<Int>.Type
/*
Vous pouvez également utiliser la carte pour convertir en un autre type
Int?Exécute une fermeture qui convertit Int en String pour le type num5, résultant en String?Recevoir 17
*/
let num5 = Optional(17)
let num6 = num5.map { val in
String(val)
} // "17"
type(of: num6)
// flat(Map
//La valeur de retour de la fermeture sera facultative
let num7 = Optional("17")
let num8 = num7.flatMap { val in
Int(val)
}
type(of: num8) // Optional<Int>.Type
//point
/*
C'est un point que nous effectuons une opération pour laquelle il n'est pas certain de renvoyer une valeur pour une constante dont l'existence est incertaine.
S'il s'agit d'une carte au lieu d'un flatMap
Le résultat final est un double wrap de type Int??Devient
*/
let num9 = Optional("17")
let num10 = num9.map { val in
Int(val)
}
type(of: num10) // Optional<Optional<Int>>.Type
//FlatMap rassemble cet état doublement incertain en un seul.
//Déballage implicite
// Wrapped!En ce qui concerne
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
//Le déballage implicite entraîne une erreur pour nul
let eee: Int! = 1
eee + 1 //Le calcul est possible de la même manière que le type Int
// var fff: Int! = nil
// fff + 1 //Une erreur d'exécution se produit car il n'y a pas de valeur
/*
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.
*/
J'ai beaucoup étudié, alors j'ai écrit un article pour le moment. Cette fois, contrairement à d'autres articles, la qualité est médiocre, je vous suis donc reconnaissant de le lire.