Swift 可选项 Optional

1、可选项

一般也叫可选类型，它允许将值设置为nil

在类型名称后面加个问号? 来定义一个可选项

//可选项
var name:String?="jack"
print(name) //Optional("jack") //并且还有警告
var age:String?
age=nil
print(age)// nil
//如果直接不定义为可选类型、不能给改属性赋值为nil
// var a:String
//a=nil  //错误信息 'nil' cannot be assigned to type 'String'

2、强制解包(Forced Unwrapping)

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

如果为nil,那么他就是空盒子

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

var age:Int?=10
//如果要从可选项中取出被包装的数据(将盒子里装的东西取出来)，需要使用感叹号! 进行强制解包
var sage = age!

sage=sage+10
print(sage) //20

var a: Int? //默认为nil
//a! 如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误

3、可选项绑定

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

var age:Int?=Int("aa") //"22" //转换成功22
if let p = age {
    print("转换成功(p)")
}else{
    print("转换失败")
} //aa 转换失败

enum Season : Int {
    case spring = 1, summer, autumn, winter
}
//6 失败  1234 成功
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")
}
//可选绑定并列条件句可以用，隔开
if let w = Int("33"),
let m = Int("44") {
      print("wm转换成功 w(w)m(m)")
}else{
    print("wm转换失败")
}//wm转换成功 w33m44
//while 循环中使用可选项绑定
//遍历数组，将遇到的正数都加起来，如果遇到负数或者非数字，停止遍历
var strs = ["10", "20", "abc", "-20", "30"]

var index = 0
var sum = 0


while let p = Int(strs[index]),p>0{
    sum+=p
    index+=1
}
print(sum) //30

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

a??b

a是可选项

b是可选项或者不是可选项

b 和 a的数据类型必须相同

如果a不为nil 就返回a

如果a为nil 就返回b

如果b不是可选项，返回a时会自动解包

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 a: Int? = nil
let b: Int? = nil
let c = a ?? b // c是Int? , nil

//??跟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

5、guard 语句 

当guard语句的条件为false时，就会执行大括号里面的代码

 当guard语句的条件为true时，就会跳过guard语句

 guard语句特别适合用来“提前退出”

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

func test(){
    guard let p = Int("33") else {
        return
    }
    guard let q = Int("44") else {
        return
    }
    print(p,q)
}

test() // 33 、4

6、隐式解包(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

 7、字符串插值

消除警告

var age:Int?=12
print("age is (age!)")//age is 12

print("age is (String(describing: age))")//age is Optional(12)

print("age is (age ?? 0)") //age is 12

8、多重可选项

var num1 : Int? = 10 //一个盒子里包含了一个10
var num2 : Int?? = num1//一个盒子里包含了带盒子的10
var num3 : Int?? = 10 //两个盒子、最里面是个10

print(num2==num3) //true

var a1 : Int? = nil // 一个空盒子 为null
var a2 : Int?? = a1// 空盒子里面包含了一个空盒子 不为空
var a3 : Int?? = nil // 为null 和a2 结构一样 单是为null
print(a2==a3)  //false //