可选项 ？
- 可选项，一般也叫可选类型，它允许将值设置为nil
- 在类型名称后面加个问号
?来定义一个可选项
类比盒子
- 可选项是对其他类型的一层包装，可以将它理解为一个盒子
- 如果为nil，那么它是个空盒子
- 如果不为nil，那么盒子里装的是：被包装类型的数据
var age: Int? //默认就是nil
print(age)//nil
age = 10
print(age)//Optional(10)
控制台打印：
nil
Optional(10)
数组案例
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))
print(get(4))
强制解包（Forced Unwrapping）
//正确的解包
let forcedAge:Int = age!
print(forcedAge)
//下面运行会报错
var ageNil: Int?
//print(ageNil!)
//Thread 1: Fatal error: Unexpectedly found nil while unwrapping an Optional value
- 如果要从可选项中取出被包装的数据（将盒子里面的东西取出来），需要使用感叹号！进行强制解包
-
如果对值为nil的可选项（空盒子）进行强制解包，将会产生运行时错误
image.png
判断可选项是否包含值---> 可选项绑定（Optional Binding）
let numer = Int("123")
if numer != nil {
print("字符串转换整数成功：\(numer!)")
} else {
print("字符串转换整数失败")
}
上面判断很麻烦下面就是语法的缩写
image.png
if let numer1 = Int("123") {
print("可选项绑定 if let 字符串转换成功",numer1)
} else {
print("字符串转换失败")
}
enum Season : Int {
case spring = 1,summer,autumn,winter
}
if let season = Season(rawValue: 6) {
print(season)
} else {
print("没有这个Season")
}
- 可以使用 可选项绑定 来判断可选项是否包含值
- 如果包含就自动解包，把值赋给一个临时的变量或常量 并返回true 否则返回false (这个值是临时的 只能在{}里面使用或者该声明后面如等价写法和while的例子)
等价写法
if let first = Int("4") {
if let second = Int("42") {
if first < second && second < 100 {
print("\(first)<\(second)<\(100)")
}
}
}
if let first = Int("4"),let second = Int("42") ,first < second && second < 100 {
print("\(first)<\(second)<\(100)")
}
while循环中使用可选项绑定
var strs = ["10","20","abc","-20"]
var index = 0
var sum = 0
while let num = Int(strs[index]),num > 0 {
sum = sum + num
index += 1
print("index = \(index)")
}
print(sum)
空合并运算符？？（Nil-Coalescing Operator）
var a: Int? = 10
var b: Int = 10
print(a ?? b)
控制台
10
- a 是可选项
- b 可以不是可选项
- b跟a的存储类型必须相同
- 如果a 不为nil ，就返回a
- 如果a 为nil 就返回b
- 如果b不是可选项，返回a时会自动解包
let e: Int? = nil
let f: Int? = 2
if let g = e ?? f {
print("if let ?? \(g)")
}
控制器：
if let ?? 2
案例 if let -> guard
func login(_ info:[String: String]) -> Bool {
var userName: String,password: String
if let tmp = info["username"] {
userName = tmp
} else {
print("请输入用户名")
return false
}
if let tmp = info["password"] {
password = tmp
} else {
print("请输入用户密码")
return false
}
print(userName,password)
return false
}
login(["username": "jack"])
login(["password":"123456"])
login(["username": "jack","password":"123456"])
image.png
func login1(_ info:[String: String]) {
guard let username = info["username"] else {
print("请输入用户名")
return
}
guard let password = info["password"] else {
print("请输入密码")
return
}
var age: Int?
guard let tmpAge = age else {
print("真的进来了！")
return
}
print(username,password)
login1(["username": "jack"])
login1(["password":"123456"])
login1(["username": "jack","password":"123456"])
}
控制台打印：
请输入密码
请输入用户名
真的进来了！
隐式解包（Implicitly Unrwapped Optional）
- 在某些情况下，可选项一旦被设定值之后，就会一直拥有值
- 在这种情况下，可以去掉检查，也不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值
- 可以在类型后面加个感叹号！定义一个隐式解包的可选项
let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
print(num1 + 6)
}
let num3: Int! = nil
//Thread 1: Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value
//let num4: Int = num3
字符串插值
/**
* 这些都交给编译器 会自己修复
*/
var agea: Int? = 10
print(agea)
/**
* Expression implicitly coerced from 'Int?' to 'Any'
* Provide a default value to avoid this warning 【Fix】---> agea ?? <#default value#>
* Force-unwrap the value to avoid this warning [Fix] ---> agea!
* Explicitly cast to 'Any' with 'as Any' to silence this warning agea as Any
*/
print("\(agea)")
/**
* String interpolation produces a debug description for an optional value; did you mean to make this explicit?
* Use 'String(describing:)' to silence this warning [Fix] -->\(String(describing: agea))
* Provide a default value to avoid this warning [Fix] --> agea ?? 0
*/
多重可选项
func more () {
var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10
print(num2 == num3)
print("num2=\(num2)","num2!=\(num2!)","num2!!=\(num2!!)")
}
func more2() {
var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil
print(num2 == num3)
}
more()
more2()
控制台：
true
num2=Optional(Optional(10)) num2!=Optional(10) num2!!=10
false
image.png
image.png
可选链概念
- 如果可选项为nil，调用方法、下标、属性失败，结果为nil
- 如果可选项不为nil，调用方法、下标、属性成功，结果会被包装可选项
- 如果结果本来就是可选项，不会进行再次包装
- 多个？可以连接在一起
- 如果链中任何一个节点是nil，那么整个链就会调用失败
class Car {
var price = 0
}
class Dog {
var weight = 0
}
class Person {
var name: String = ""
var dog: Dog = Dog()
var car:Car? = Car()
func age() -> Int {
18
}
func eat() {
print("Person eat")
}
subscript(index: Int) -> Int {
index
}
}
var person:Person? = Person()
print(person is Person)// true
print(person?.age())// Optional(18)
print(person!.age())// 18
print(person?[6])// Optional(6)
Any,AnyObject
var stu: Any = 10
stu = "jack"
print(stu)
stu = Person()
print(stu)
var data = [Any]()
data.append(1)
data.append("222")
data.append({10})
- Swift提供了2种特殊的类型：Any、AnyObject
- Any：可以代表任意类型（枚举、结构体、类，也包括函数类型）
- AnyObject：可以代表任意类类型（在协议后面写上：AnyObject代表只有类能遵守这个协议）在协议后面加上class 也是代表只有类能遵守这个协议
is、as？、as!、as
print(stu is String)
print(stu is Person)
stu = "wpp"
(stu as? Person)?.eat()
stu = Person()
(stu as? Person)?.eat()
(stu as! Person).eat()
- is用来判断是否为某种类型，as 用来做强制类型转换
- !强制解包
- ？可选
