认识可选值
之前我们在写代码过程中早就接触过可选值，比如我们在代码中这样定义:
class IFLPerson {
var name: String?
}
当前的name，我们就称之为可选值
var name: String? == var name: Optional<String>
这两种写法是等同的
nameOptional的本质是什么，我们直接跳转到 源码 打开 Optional.swift 文件
既然Optional本质是枚举，那么我们也可以实现一个自定义的Optional
比如给定任一自然数，如果自然数是奇数则返回，否则返回nil, 该如何设计
enum IFLOptional<Value> {
case some(Value)
case none
}
func getOddValue(_ value: Int) -> IFLOptional<Int> {
if value % 2 == 0 {
return .none
}
return .some(value)
}
// 给定一个数组，删除数组中的所有奇数
var array = [1, 2, 3, 4, 5, 6, 7, 8, 101]
for elem in array {
let value = getOddValue(elem)
switch value {
case let .some(value):
array.remove(at: array.firstIndex(of: value)!)
case .none:
print("\(value) not exist")
}
}
print("-------------")
print(array)
结果
[2, 4, 6, 8]
如果我们把上面的 getOddValue 返回值更换一下，其实就和系统的Optional 使用没什么差别
func getOddValue(_ value: Int) -> Int? {
if value % 2 == 0 {
return .none
}
return .some(value)
}
其实就是利用当前编译器的类型检查来达到语法书写层面的安全性
当然如果每一个可选值都用模式匹配的方式来获取值，在代码书写上就比较繁琐，
我们还可以使用 if let 的方式来进行可选值绑定
if let value = value {
array.remove(at: array.firstIndex(of: value))
}
还可以使用 guard let
如果 if let 凭空多了一个分支，guard let 是降低分支层次的办法
可选链
我们都知道在OC 中我们给一个nil 对象发送消息什么也不会发生
Swift中我们是没办法向一个nil对象直接发送消息的，但是借助可选链可以达到类似的效果
let str: String? = "abc"
let upperStr = str?.uppercased() // Optional<"ABC">
var str1: String?
let upperStr1 = str1?.uppercased() // nil
print(upperStr)
print(upperStr1)
结果
Optional("ABC")
nil
再来看下面这段代码输出什么
let str: String? = "aBc"
let lowerStr = str?.uppercased().lowercased()
var str1: String?
let lowerStr1 = str1?.uppercased().lowercased()
print(lowerStr)
print(lowerStr1)
结果
Optional("abc")
nil
同样的 可选链对于下标和函数调用 也适用
var closure: ((Int) -> ())?
closure?(1) // closure为nil 不执行
closure为nil 不执行
let dict: [String: Any]? = ["key1": 1, "key2": 2]
print(dict?["key1"])
print(dict?["key3"])
结果
Optional(1)
nil
?? 运算符 (空合并运算符)
( a ?? b ) 将对可选类型 a 进行空判断，如果 a 包含一个值就进行解包，否则就返回 一个默认值 b .
- 表达式 a 必须是 Optional 类型
- 默认值 b 的类型必须要和 a 存储值的类型保持一致
运算符重载
在源码中我们可以看到除了重载了 ?? 运算符，
Optional 类型还重载了 == , ?= 等 等运算符，实际开发中我们可以通过重载运算符简化我们的表达式
比如在开发中我们定义了一个二维向量，这个时候我们想对两个向量进行基本的操作，
那么我们就可以通过重载运算符来达到我们的目的
struct Vector {
let x: Int
let y: Int
}
extension Vector {
static func + (firstVector: Vector, secondVector: Vector) -> Vector {
return Vector(x: firstVector.x + secondVector.x, y: firstVector.y + secondVector.y)
}
static prefix func - (vector: Vector) -> Vector {
return Vector(x: -vector.x, y: -vector.y)
}
static func - (firstVector: Vector, secondVector: Vector) -> Vector {
return firstVector + -secondVector
}
}
let v1 = Vector(x: 5, y: 10)
let v2 = Vector(x: 3, y: 4)
let v3 = v1 + v2
let v4 = v1 - v2
let v5 = -v1
print(v3)
print(v4)
print(v5)
结果
Vector(x: 8, y: 14)
Vector(x: 2, y: 6)
Vector(x: -5, y: -10)
隐士解析可选类型
隐式解析可选类型是可选类型的一种，使用的过程中和非可选类型无异
它们之间唯一 的区别是，隐式解析可选类型是你告诉 Swift 编译器，在运行时访问时，值不会 为 nil, 但是如果你导致nil值，运行报错
var age: Int
var age1: Int!
age = nil // 报错 'nil' cannot be assigned to type 'Int'
age1 = nil
var age: Int？
var age1: Int!
age = nil // 改为可选值 就可以 赋值nil了
age1 = nil
let x = age1 % 2 // 这里不需要做解包的操作，编译器已经帮我们做了
其实日常开发中，我们比较常见的一种隐士可选类型
@IBOutlet weak var button: UIButton!
IBOutlet类型是Xcode强制为可选类型的，因为它不是在初始化时赋值的，而是在加载视图的时候
你可以把它设置为普通的可选类型，但是如果这个视图加载正确，它是不会为空的
与可选值有关的高阶函数
- map : 这个方法接受一个闭包，如果可选值有内容则调用这个闭包进行转换
var dict = ["one": "1", "two": "2"]
let result = dict["one"].map{ Int($0) }
print(result)
结果
Optional(Optional(1))
上面的代码中我们从字典中取出字符串”1”，并将其转换为Int类型，
但因为String转换成 Int不一定能成功，所以返回的是Int?类型，
而且字典通过键不一定能取得到值，所以map 返回的也是一个Optional，
所以最后上述代码result的类型为 Int?? 类型
那么如何把我们的双重可选展平开来，这个时候我们就需要使用到
- flatMap: 可以把结果展平成为单个可选值
var dict = ["one": "1", "two": "2"]
let result = dict["one"].flatMap{ Int($0) }
print(result)
结果
Optional(1)
- 注意，这个方法是作用在Optional的方法，而不是作用在 Sequence上的
- 作用在Sequence上的flatMap 在 Swift4.1 中被更名为 compactMap, 该方法可以将序列中的nil过滤出去
let array1 = ["1", "2", "3", nil]
let result2 = array1.compactMap {
$0
}
print(result2)
let array2 = ["1", "2", "3", "four"]
let result3 = array2.compactMap {
Int($0)
}
print(result3)
结果
["1", "2", "3"]
[1, 2, 3]
元类型、AnyClass、Self (self)
- AnyObject: 代表任意类的 instance，类的类型，仅类遵守的协议
- Any: 代表任意类型，包括 funcation 类型或者 Optional 类型
- AnyClass: 代表任意实例的类型
