Syntaxe de base Swift - facultative

Facultatif

• Facultatif, également généralement appelé type facultatif, permet de définir la valeur sur zéro
• Ajoutez un point d'interrogation ? après le nom du type pour définir une option

var name: String? = "CSDN"
name = nil

var age: Int? //默认就是nil
age = 30
age = nil

var array = [2, 4, 6, 8]

func getNumber(_ index: Int) -> Int? {
    
    
    if index < 0 || index >= array.count {
    
    
        return nil
    }
    return array[index]
}

print(getNumber(1)) //Optional(4)
print(getNumber(-1)) //nil
print(getNumber(4)) //nil

Déballage forcé

• Les options facultatives sont une couche d'emballage pour d'autres types, qui peut être comprise comme une boîte
• Si nul , alors c'est une case vide
• Si ce n'est pas nil , alors la boîte contient : des données de type compressé

var age: Int? //默认就是nil
age = 10
age = nil

• Si vous souhaitez extraire les données compressées des éléments optionnels (retirer le contenu de la boîte), vous devez utiliser le point d'exclamation ! pour forcer le déballage

var age: Int? = 20

let ageInt: Int = age!

print(ageInt) //20

• Si vous forcez le décompression d'un nil facultatif (boîte vide), une erreur d'exécution se produira.

var age: Int?
age!

Erreur fatale : nil trouvé de manière inattendue lors du déballage d'une valeur facultative

Déterminer si un élément facultatif contient une valeur

let number = Int("123")

if number != nil {
    
    
    print("字符串转成数字成功为：\(number!)")
}else{
    
    
    print("字符串转成数字失败")
}
// 字符串转成数字成功为：123

Reliure facultative

• Vous pouvez utiliser la liaison facultative pour déterminer si un élément facultatif contient une valeur
• S'il est inclus, décompressez automatiquement, attribuez la valeur à une constante temporaire ( let ) ou à une variable ( var ) et renvoyez true , sinon renvoyez false

if let number = Int("123") {
    
    
    print("字符串转成数字成功为：\(number)")
    // number 是强制解包之后的Int值
    // number 作用域仅限于这个大括号
}else{
    
    
    print("字符串转成数字失败")
}
// 字符串转成数字成功为：123

enum Season : Int {
    
    
    case spring = 1, summer, autumn, winter
}

if let season = Season(rawValue: 8){
    
    
    switch season {
    
    
    case .spring:
        print("the season is spring")
    default:
        print("the season is other")
    }
} else {
    
    
    print("no such season")
}
// no such season

Écriture équivalente

if let first = Int("5") {
    
    
    if let second = Int("45") {
    
    
        if first < second && second < 50 {
    
    
            print("\(first) < \(second) < 50")
        }
    }
}
// 5 < 45 < 50

if let first = Int("5"),
   let second = Int("45"),
   first < second && second < 50 {
    
    
    print("\(first) < \(second) < 50")
}
// 5 < 45 < 50

Utilisation de liaisons facultatives dans les boucles while

//遍历数组，将遇到 的正整数都加起来，如果遇到负数或者非数字，则停止遍历
var array = ["10", "20", "30", "ab", "-20", "40"]

var index = 0
var sum = 0
while let num = Int(array[index]), num > 0 {
    
    
    sum += num
    index += 1
}
print(sum)

Néant – Opérateur de coalescence ??

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T

• un ?? b
• a est facultatif
• b est facultatif ou non facultatif
• Les types de stockage de b et a doivent être les mêmes
• Si a n'est pas nul , renvoie un
• Si a est nul , renvoie b
• Si b n'est pas facultatif, il sera automatiquement décompressé lors du retour d'un

let a: Int? = 1
let b: Int? = 2
let c = a ?? b // c是Int? , Optional(1)

let a: Int? = nil
let b: Int? = 2
let c = a ?? b // c是Int? , Optional(2)

let a: Int? = nil
let b: Int? = nil
let c = a ?? b // c是Int? , nil

let a: Int? = 1
let b: Int = 2
let c = a ?? b // c是Int , 1

let a: Int? = nil
let b: Int = 2
let c = a ?? b // c是Int , 2

let a: Int? = nil
let b: Int = 2
//如果不使用 ?? 运算符
let c: Int
if let tmp = a {
    
    
    c = tmp
} else {
    
    
    c = b
}

Utiliser plusieurs ?? ensemble

let a: Int? = 1
let b: Int? = 2
let c = a ?? b ?? 3 // c是Int , 1

let a: Int? = nil
let b: Int? = 2
let c = a ?? b ?? 3 // c是Int , 2

let a: Int? = nil
let b: Int? = nil
let c = a ?? b ?? 3 // c是Int , 3

?? Utilisé conjointement avec if let

let a: Int? = nil
let b: Int? = 2
if let c = a ?? b {
    
    
    print(c)
}
//类似于 if a != nil || b != nil

let a: Int? = nil
let b: Int? = 2
if let c = a , let d = b {
    
    
    print(c)
    print(d)
}
// 类似于 if a != nil && b != nil

si l'instruction implémente la connexion

func login(_ info: [String : String]) {
    
    
    let username: String
    if let tmp = info["username"] {
    
    
        username = tmp
    } else {
    
    
        print("请输入用户名")
        return
    }
    let password: String
    if let tmp = info["password"] {
    
    
        password = tmp
    } else {
    
    
        print("请输入密码")
        return
    }
    // if username ....
    // if password ....
    print("用户名：\(username)", "密码：\(password)", "登陆ing")
}
login(["username" : "jack", "password" : "123456"]) // 用户名：jack 密码：123456 登陆ing
login(["password" : "123456"]) // 请输入密码
login(["username" : "jack"]) // 请输入用户名

déclaration de garde

guard 条件 else {
    
    
    // do something....
    退出当前作用域
    //return、break、continue、throw error
}

• Lorsque la condition de l'instruction guard est false , le code entre accolades sera exécuté.
• Lorsque la condition de l' instruction de garde est vraie, l' instruction de garde sera ignorée
• Le relevé de garde est particulièrement adapté aux "sorties anticipées"
• Lorsque vous utilisez l'instruction guard pour une liaison facultative, les constantes liées ( let ) et les variables ( var ) peuvent également être utilisées dans la portée externe.

func login(_ info: [String : String]){
    
    
    guard let username = info["username"] else {
    
    
        print("请输入用户名")
        return
    }
    guard let password = info["password"] else {
    
    
        print("请输入密码")
        return
    }
    // if username ...
    // if password ...
    print("用户名：\(username)","密码：\(password)","登录ing")
}
login(["username" : "jack", "password" : "123456"]) // 用户名：jack 密码：123456 登陆ing
login(["password" : "123456"]) // 请输入密码
login(["username" : "jack"]) // 请输入用户名

Implicitement déballé Facultatif

• Dans certains cas, une fois qu'une option est définie, elle conserve sa valeur.
• Dans ce cas, vous pouvez supprimer la vérification et la décompresser à chaque accès, car cela garantira que la valeur est disponible à chaque accès.
• Vous pouvez ajouter un point d'exclamation après le type ! Définir une option de décompression implicite

let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
    
    
    print(num1 + 6) // 16
}
if let num3 = num1 {
    
    
    print(num3) // 10
}

let num1: Int! = nil
//Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value
let num2: Int = num1

Interpolation de chaîne

• Le compilateur émettra un avertissement lors de l'interpolation éventuelle de chaînes ou de l'impression directe.

var age: Int? = 10
print("My age is \(age)")

• Il existe au moins 3 façons d'éliminer l'avertissement

print("My age is \(age!)")
//My age is 10

print("My age is \(String(describing: age))")
//My age is Optional(10)

print("My age is \(age ?? 0)")
//My age is 10

Plusieurs options

var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10

print(num2 == num3) // true

• Vous pouvez utiliser la variable frame de commande lldb –R ou fr v –R pour voir la différence.

var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil

print(num2 == num3) // false

(num2 ?? 1) ?? 2 // 2
(num3 ?? 1) ?? 2 // 1