swift -- Optional可选项(Optional),本质是个枚举用？来定义可选类型用！强制解包从可选项里

可选项(Optional),本质是个枚举

public enum Optional<Wrapped>  {
    case none
    case some(Wrapped)
    }

用？来定义可选类型

//两种方式效果是一样的
var age: Int? = 10
var age1: Optional<Int> = Optional(10)

//允许将值置为nil 
var name: String? = "Jack"
name = nil 

//默认值就是nil
var age: Int?

用！强制解包

从可选项里取值需要使用 感叹号! 进行强制解包

var age: Int = 10
var ageInt: Int = age!
ageInt += 10

判断可选项是否包含值

let number = Int("123")
if number != nil {
print("字符串转换整数成功:\(number!)")
} else {
print("字符串转换整数失败") 
}
// 字符串转换整数成功:123

如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误

Fatal error: Unexpectedly found nil while unwrapping an Optional value

可选项绑定

可以使用可选项绑定来判断可选项是否包含值
如果包含就自动解包，把值赋给一个临时的常量(let)或者变量(var)，并返回true，否则返回false

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

if let first = Int("4") {
    if let second = Int("42") {
        if first < second && second < 100 {
            print("\(first) < \(second) < 100")
        }
    }
}
// 4 < 42 < 100

=============等价写法===================

if let first = Int("4"),
   let second = Int("42"),
   first < second && second < 100 {
    print("\(second) < \(second) < 100")
}

while循环中使用可选项绑定

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

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

print(sum)

空合并运算符 ??(Nil-Coalescing Operator)

a ?? b 注意点：

左边a必须是可选项
右边b是可选项或者不是可选项
b 跟 a 的存储类型必须相同
如果 a 不为nil，就返回 a
如果 a 为nil，就返回 b
如果 b 不是可选项，返回 a 时会自动解包

总结: 返回值去取决于b的类型

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

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

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

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

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

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

多个??一起使用

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

??跟if let配合使用

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

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

Equatable

Optional遵守Equatable协议重载了 == 运算符

var age: Int? = 1
var age1: Optional<Int> = Optional(10)
if age == age1 {
    print("相等")
}

guard

当guard语句的条件为false时，就会执行大括号里面的代码
当guard语句的条件为true时，就会跳过guard语句退出当前作用域
guard语句特别适合用来“提前退出”
当使用guard语句进行可选项绑定时,绑定的常量(let)、变量(var)也能在外层作用域中使用

guard 条件 else {
// do something....
// return、break、continue、throw error
}

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")
}

隐式解包(Implicitly Unwrapped Optional)

在某些情况下，可选项一旦被设定值之后，就会一直拥有值
在这种情况下，可以去掉检查，也不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值
可以在类型后面加个感叹号 ! 定义一个隐式解包的可选项

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


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

字符串插值

可选项在字符串插值或者直接打印时，编译器会发出警告

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

至少有3种方法消除警告

//第一种方式
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