[Swift5.1] 5-可选项

可选项（Optional）

• 可选项，一般也叫可选类型，它允许将值设置为nil
• 在类型名称后面加个问号 ? 来定义一个可选项

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

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

var array = [1, 15, 40, 29]
func get(_ index: Int) -> Int? {
    if index < 0 || index >= array.count {
        return nil
    }
    return array[index]
}

print(get(1)) // Optional(15)
print(get(-1)) // nil
print(get(4)) // nil

强制解包（Forced Unwrapping）

可选项本质: 可选项是对其他类型的一层包装，可以将它理解为一个盒子

• 如果为nil，那么它是个空盒子
• 如果不为nil，那么盒子里装的是：被包装类型的数据

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

• 如果要从可选项中取出被包装的数据（将盒子里装的东西取出来），需要使用感叹号 ! 进行强制解包

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

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

var age: Int?  age!
//Fatal error: Unexpectedly found nil while unwrapping an Optional value

判断可选项是否包含值

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

可选项绑定（Optional Binding）

• 可以使用可选项绑定来判断可选项是否包含值
• 如果包含就自动解包，把值赋给一个临时的常量(let)或者变量(var)，并返回true，否则返回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: 6) {
    switch season {
        case .spring:
            print("the season is spring")
    default:
            print("the season is other")
    }
} else {
    print("no such season")
}
// no such season

等价写法

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

注意: 同一个if中, 可选项绑定要和其他语句以逗号隔开

if let first = Int("4"),  let second = Int("42"),
    first < second && second < 100 {
    print("\(second) < \(second) < 100")
}
// 4 < 42 < 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）

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

a ?? b

• a 是可选项
• b 是可选项 或者 不是可选项
• b 跟 a 的存储类型必须相同
• 如果 a 不为nil，就返回 a
• 如果 a 为nil，就返回 b
• 如果 b 不是可选项，返回 a 时会自动解包
• 如果 a 和 b都是可选项, 返回值还是可选项

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
}

多问号可选项:

• 空合并运算符源码实现:

//a 可选类型,  b有值
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws ->T) rethrows -> T {
    switch optional {
    case .some(let value):
        return value
    case .none:
        return try defaultValue()
}

// a和b同时为可选类型
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws ->T?) rethrows -> T? {
    switch optional {
    case .some(let value):
        return value
    case .none:
        return try defaultValue()
}

1> a和b同时有值:

var age1: Int???? = 10
var age2: Int? = 20
print(age1 ?? age2 ) 
// Optional(Optional(Optional(10)))

var age1: Int? = 10
var age2: Int???? = 20
print(age1 ?? age2 ) 
// 10

2> a为nil, b有值

var age1: Int???? = nil
var age2: Int? = 20
print(age1 ?? age2 )
// Optional(Optional(Optional(20)))

var age1: Int? = nil
var age2: Int???? = 20
print(age1 ?? age2 )
// Optional(Optional(Optional(Optional(20))))

3> a和b同时为nil

var age1: Int???? = nil
var age2: Int? = nil
print(age1 ?? age2 )
// Optional(Optional(nil))

var age1: Int? = nil
var age2: Int????? = nil
print(age1 ?? age2 )
// nil

多问号可选项总结
结论1: a有值, 返回解包一次的a
结论2: a值为nil, b有值. b先转换为a类型, 再返回解包一次的b
结论3: a和b同时为nil

多个 ?? 一起使用

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配合使用

• 下面类似于if a != nil || b != nil

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语句实现登陆

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"]) // 请输入用户名

guard语句

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

guard语句用法:
1)当guard语句的条件为false时，就会执行大括号里面的代码
2)当guard语句的条件为true时，就会跳过guard语句
3)guard语句特别适合用来“提前退出”

• 当使用guard语句进行可选项绑定时，绑定的常量(let)、变量(var)也能在外层作用域中使用

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)")
// My age is Optional(10)

至少有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

多重可选项

实例1:

var num1: Int? = 10   //包装Int类型的可选类型
var num2: Int?? = num1  // 包装一个可选类型的可选类型
var num3: Int?? = 10
print(num2 == num3) // true
print(num1 == num3) // true

• 可以使用lldb指令 frame variable –R 或者 fr v –R 查看区别

• 注意: == 左右两边是有值的可选类型, 会先将少的问号转换为多问号的类型,再进行递归解包, 最后比较值.

实例2:

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

print(num2 == num3) // false
//num2 和num3类型相同, 值不同
print(num1 == num3) // false  
// num1和num3类型不同

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

结论1: 比较可选类型, 如果底层包装的值相同, 则比较时返回true.
结论2: 如果比较两个可选项, 值都为nil, 类型不同比较结果为false.