Swift之可选项

本文首发于个人我的博客

定义

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

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


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

复制代码

强制解包

• 可选项是对其余类型的一层包装，能够将它理解为一个盒子
• 若是为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

复制代码

可选项绑定

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

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


// 字符串转换整数成功:123
复制代码

eg:

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

eg:

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

举例以下：

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

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 = a ?? b // c是Int? , Optional(2)
复制代码

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

// 使用 ？？ 运算符
let c = a ?? b // c是Int? , 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配合使用

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
复制代码

guard语句

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

guard 条件 else {
// do something....
退出当前做用域
// return、break、continue、throw error }
复制代码

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

假设咱们有个登录的需求，要求输入帐号，密码。缺一不可。

用if语句书写

//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
	}
	
	// 能来到这里，说明，username和password都是有值的
	// if username ....
	// if password ....
	print("用户名:\(username)", "密码:\(password)", "登录ing")
}
 
// 调用
login(["username" : "jack", "password" : "123456"]) // 用户名:jack 密码:123456 登录ing 

login(["password" : "123456"]) // 请输入密码

login(["username" : "jack"]) // 请输入用户名
复制代码

若是用guard来书写

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) //10
}
复制代码

注意不能设置为nil

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

复制代码

尽可能不要使用这个强制解包。 除非你设计接口，不但愿接收空值，若是别人传Nil过来，直接报错

字符串插值

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

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
复制代码

多重可选项

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

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


print(num2 == num3) // true

复制代码

还有下面这种

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


print(num2 == num3) // false
(num2 ?? 1) ?? 2 // 2
(num3 ?? 1) ?? 2 // 1

复制代码

参考资料:

Swift官方源码

从入门到精通Swift编程