Stay hungry, Stay foolish.

听月的博客

0%

Swift可选项

发表于 分类于
本文字数： 6.4k 阅读时长 ≈ 6 分钟

可选项是什么？

You use optionals in situations where a value may be absent. An optional represents two possibilities: Either there is a value, and you can unwrap the optional to access that value, or there isn’t a value at all.

可选项，一般也叫可选类型，它代表2种可能，一种可能是有值，一种可能是没值。没值代表值缺失的情况，使用nil来表示，有值的时候，可以通过解包获取真正的值。也可以手动将值设置为nil。Swift中的可选项适用于对象类型、结构体类型、枚举类型和基础类型。而Objective-C中只有对象类型的值可以为nil。

如何定义可选项？

在类型名称后面加问号？来定义一个可选项。可选项的值默认为nil，非可选项没有默认值，需要初始化给定默认值。

1
2
3
4
5
6
7
8
var name: String? = "张三" // 可选项
print(String(describing: name))
name = nil // 可选项可以设置成nil

var name1: String = "李四" // 非可选项
print(name1)
// 非可选项设置nil，会报错"'nil' cannot be assigned to type 'String'"
// name1 = nil

最终控制台打印结果：

1
2
Optional("张三")
李四

可选项默认值为nil，非可选项没有默认值，并且非可选项在使用前需要赋值。

强制解包

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

  • 如果为nil，那么它是一个空盒子

  • 如果不为nil，那么盒子里装的是：被包装类型的数据
    代码示例：

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

    图形表示：

  • 如果需要从可选项中取出被包装的数据，需要使用感叹号!进行强制解包

    1
    2
    3
    4
    5
    6
    7
    var age: Int? = 10
    print(String(describing: age))
    let ageValue: Int = age!
    print(ageValue)
    //控制台打印数据
    //Optional(10)
    //10

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

    1
    2
    var age: Int?
    print(age!)

    会产生错误：Fatal error: Unexpectedly found nil while unwrapping an Optional value。

判断可选项是否包含值

可选值可以和nil直接进行比较，用于判断可选项是否包含值。

1
2
3
4
5
6
7
8
let number = Int("aa123")
if number != nil {
    print("字符串转换成功:\(number!)")
} else {
    print("字符串转换失败")
}
//控制台打印：
//字符串转换失败

可选项绑定(Optional Binding)

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

示例1:

1
2
3
4
5
6
7
8
9
if let number = Int("123") {
    print("字符串转换成功:\(number)")
    // number是强制解包之后的Int值
    // number作用域仅限于这个大括号
} else {
    print("字符串转换失败")
}
//控制台打印结果：
//字符串转换成功:123

示例2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
enum Season : Int {
    case spring = 1, summer, autumn, winter
}
if let season = Season(rawValue: 6) {
    switch season {
    case .spring:
        print("season is spring")
    default:
        print("season is other")
    }
} else {
    print("no such season")
}
//控制台打印结果：
//no such season

示例3：多条件组合判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 一般写法
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("\(first) < \(second) < 100")
}
//控制台打印结果：
//4 < 42 < 100

示例4：while循环中使用可选项绑定

1
2
3
4
5
6
7
8
9
10
11
12
// 遍历数组，将遇到的正数都加起来，如果遇到负数或非数字，停止遍历
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)
//控制台打印结果：
//30

空合并运算符 ?? (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 时会自动解包
  • 计算结果的类型与 b的类型相同

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 示例1
let a: Int? = 1
let b: Int? = 2
let c = a ?? b
print(String(describing: c)) // c是Int? , Optional(1)

// 示例2
let a: Int? = nil
let b: Int? = 2
let c = a ?? b
print(String(describing: c)) // c是Int? , Optional(2)

// 示例3
let a: Int? = nil
let b: Int? = nil
let c = a ?? b
print(String(describing: c)) // c是Int? , nil

// 示例4
let a: Int? = 1
let b: Int = 2
let c = a ?? b
print(String(describing: c)) // c是Int , 1

// 示例5
let a: Int? = nil
let b: Int = 2
let c = a ?? b
print(String(describing: c)) // c是Int , 2

// 示例6，与示例5等价，不使用??运算符的时候
let a: Int? = nil
let b: Int = 2
let c: Int
// 如果不使用??运算符
if let temp = a {
    c = temp
} else {
    c = b
}

多个??一起使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 示例1
let a: Int? = 1
let b: Int? = 2
let c = a ?? b ?? 3
print(String(describing: c)) // c是Int，1

// 示例2
let a: Int? = nil
let b: Int? = 2
let c = a ?? b ?? 3
print(String(describing: c)) // c是Int，2

// 示例3
let a: Int? = nil
let b: Int? = nil
let c = a ?? b ?? 3
print(String(describing: c)) // c是Int，3

??跟if let配合使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 示例1
let a: Int? = nil
let b: Int? = 2
if let c = a ?? b { // 类似于 if a != nil || b != nil
    print(c)
}
//控制台打印结果：
//2

// 示例2
let a: Int? = nil
let b: Int? = 2
if let c = a, let d = b { // 类似于 if a != nil && b != nil
    print(c)
    print(d)
}
print("123")
//控制台打印结果:
//123

guard语句

1
2
3
4
5
guard 条件 else {
    // do something...
    退出当前作用域
    // return、break、continue、throw error
}
  • 当guard语句的条件为false时，就会执行大括号里面的代码
  • 当guard语句的条件为true时，就会跳过guard语句
  • guard语句特别适合用来”提前退出”
  • 当使用guard语句进行可选项绑定时，绑定的常量(let)、变量(var)也能在外层作用域中使用
1
2
3
4
5
6
7
8
9
10
11
12
13
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)", "登录...")
}

隐式解包(Implicitly Unwrapped Optional)

  • 在某些情况下，可选项一旦被设定值后，就会一直拥有值
  • 在这种情况下，可以去掉检查，也不必每次访问时都进行解包，因为它能确定每次访问的时候都是有值
  • 可以在类型后面加个!定义一个隐式解包的可选项
1
2
3
4
5
6
7
8
9
10
11
12
let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
    print(num1 + 6) // 16
}
if let num3 = num1 {
    print(num3) // 10
}


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

字符串插值中使用可选项

  • 可选项在字符串插值或者直接打印时，编译器会发出警告
    1
    2
    var age: Int? = 10
    print("My age is \(age)") // 此处会出现警告
  • 至少有3种方法消除警告
    1
    2
    3
    4
    var age: Int? = 10
    print("My age is \(age!)")
    print("My age is \(String(describing: age))")
    print("My age is \(age ?? 0)")

多重可选项

1
2
3
4
5
6
var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10
print(num2 == num3) // true, 值相同
print(num1 == num2) // true, 值相同
print(num1 == num3) // true, 值相同

以上代码可以按照下图理解：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(lldb) fr v -R num1
(Swift.Optional<Swift.Int>) num1 = some {
  some = {
    _value = 10
  }
}
(lldb) fr v -R num2
(Swift.Optional<Swift.Optional<Swift.Int>>) num2 = some {
  some = some {
    some = {
      _value = 10
    }
  }
}
(lldb) fr v -R num3
(Swift.Optional<Swift.Optional<Swift.Int>>) num3 = some {
  some = some {
    some = {
      _value = 10
    }
  }
}
(lldb)

空值示例：

1
2
3
4
5
6
var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil
print(num2 == num3) // false, 值不相同
print(num1 == num2) // true, 值相同
print(num1 == num3) // false, 值不相同

以上代码可以按照下图理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(lldb) fr v -R num1
(Swift.Optional<Swift.Int>) num1 = none {
  some = {
    _value = 0
  }
}
(lldb) fr v -R num2
(Swift.Optional<Swift.Optional<Swift.Int>>) num2 = some {
  some = none {
    some = {
      _value = 0
    }
  }
}
(lldb) fr v -R num3
(Swift.Optional<Swift.Optional<Swift.Int>>) num3 = none {
  some = some {
    some = {
      _value = 0
    }
  }
}
(lldb)