一. 可选链(Optional Chaining)
- 如果可选项为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()
//这样强制解包有风险,如果person是nil,使用nil调用方法会报错
var age1 = person!.age() // Int
//age是Int?类型的,不会进行再次包装
var age2 = person?.age() // Int?
var name = person?.name // String?
var index = person?[6] // Int?
Value of optional type 'Person?' must be unwrapped to refer to member 'eat' of wrapped base type 'Person'
如果
person
是可选类型两种方式,一种是在
person
后面加感叹号!
,进行强制解包var result = person!.eat()
使用感叹号
!
强制解包这种做法不安全,一旦person
对象为nil
,程序就会崩溃.另一种是加问号
?
:加
?
的意思时会先判断person
对象是否为nil
,如果为nil
,就不会再调用eat
,直接返回nil
;
func getName() -> String { "jack" }
// 如果person是nil,不会调用getName()
person?.name = getName()
- 如何判断可选项调用方法是否成功?
var person : Person?
if let _ = person?.eat() { // ()?
print("eat调用成功")
} else {
print("eat调用失败")
}
Swift里面,如果方法调用没有返回值就相当于返回一个空元祖(),所以可以根据是否返回空元祖来判断方法是否调用成功
- 多个?链接在一起就称为可选链,
如果链中任何一个节点是nil,那么整个链就会调用失败:
var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?
字典通过key获取的值都是可选类型,可选类型使用的时候要加?
//字典
var scores = ["Jack": [86, 82, 84], "Rose": [79, 94, 81]]
//通过字典的key获取值有可能获取失败,所以结果是可选类型的数组
scores["Jack"]?[0] = 100
//可选类型的数组通过下标访问成员需要加?
scores["Rose"]?[2] += 10
scores["Kate"]?[0] = 88
可选项不会进⾏再次包装,除⾮你给他指定类型:
var num1: Int? = 5
var num2: Int?? = 10
print(num2) //Optional(Optional(10))
var dict: [String : (Int, Int) -> Int] = [
"sum" : (+),
"difference" : (-)
]
//返回的函数是个可选类型,函数调用的时候也要加?
var result = dict["sum"]?(10, 20) // Optional(30)
二. 协议(Protocol)
1. 协议简介
协议可以用来定义方法、属性、下标
的声明,协议可以被枚举、结构体、类遵守(多个协议之间用逗号隔开)
protocol Drawable {
func draw() //方法声明
var x: Int { get set } //属性声明
var y: Int { get }
subscript(index: Int) -> Int { get set } //下标声明
}
- 协议可以被枚举、结构体、类遵守(多个协议之间用逗号隔开)
protocol Test1 {}
protocol Test2 {}
protocol Test3 {}
class TestClass : Test1, Test2, Test3 {}
- 协议中定义方法时不能有默认参数值
- 默认情况下,协议中定义的内容必须全部都实现
- 也有办法办到只实现部分内容
2. 协议中的属性
-
协议中定义属性时必须用var关键字(因为属性可能通过计算属性来实现,将来返回什么不确定)
-
实现协议时的属性权限要不小于协议中定义的属性权限
-
协议中属性定义成get set,可以用var存储属性或者get set计算属性去实现
-
协议中定义成get,用任何属性(let y、只有get的计算属性、有get set的计算属性)都可以实现
-
如下类遵守Drawable协议:
protocol Drawable {
func draw() //方法声明
var x: Int { get set } //属性声明,必须用var
var y: Int { get }
subscript(index: Int) -> Int { get set } //下标
}
//1:
class Person : Drawable {
var x: Int = 0
let y: Int = 0
func draw() {
print("Person draw")
}
subscript(index: Int) -> Int {
set {}
get { index }
}
}
//2:
class Person : Drawable {
var x: Int {
get { 0 }
set {}
}
var y: Int { 0 }
func draw() { print("Person draw") }
subscript(index: Int) -> Int {
set {}
get { index }
}
}
- 定义属性时必须用var关键字
- 实现协议时的属性权限要不小于协议中定义的属性权限
3. 协议关键字
- static、class
为了保证枚举、结构体、类通用,协议中必须用static定义类型方法、类型属性、类型下标。
但是,具体使用的时候如果是类,还是可以用class的。
我们知道
class
和static
都可以用来定义类型计算属性,类型方法,类型下标.但是如果要在协议中定义类型方法,类型属性只能用static
.因为协议可以被类,结构体,枚举遵守.而class
只能在类中使用.
protocol Drawable {
static func draw()
}
class Person1 : Drawable {
class func draw() {
print("Person1 draw")
}
}
class Person2 : Drawable {
static func draw() {
print("Person2 draw")
}
}
- mutating
只有将协议中的实例方法标记为mutating,才允许枚举、结构体的具体实现修改自身内存,在实现的时候,枚举、结构体需要加mutating,类不用加mutating。
protocol Drawable {
mutating func draw()
}
class Size : Drawable {
var width: Int = 0
func draw() {
width = 10
}
}
struct Point : Drawable {
var x: Int = 0
//只有在协议中先加上mutating,在枚举、结构体中实现的时候才可以在这里加mutating
mutating func draw() {
x = 10
}
}
- init
协议中还可以定义初始化器init,非final类实现时必须加上required
protocol Drawable {
init(x: Int, y: Int)
}
class Point : Drawable {
required init(x: Int, y: Int) {}//必须加上required
}
final class Size : Drawable {
init(x: Int, y: Int) {}
}
如果从协议实现的初始化器,刚好是重写了父类的指定初始化器,那么这个初始化必须同时加required、override
protocol Livable {
init(age: Int)
}
class Person {
init(age: Int) {}
}
//required来自协议,override来自父类
class Student : Person, Livable {
required override init(age: Int) {//重写了父类的指定初始化器,那么这个初始化必须同时加required、override
super.init(age: age)
}
}
- init、init?、init!
init:非可失败初始化器
init?:可失败初始化器
init!:可失败初始化器(隐式解包)
协议中定义的init?、init!,可以用init、init?、init!去实现
协议中定义的init,可以用init、init!去实现
protocol Livable {
init()
init?(age: Int)
init!(no: Int)
}
class Person : Livable {
required init() {}
// required init!() {}
required init?(age: Int) {}
// required init!(age: Int) {}
// required init(age: Int) {}
required init!(no: Int) {}
// required init?(no: Int) {}
// required init(no: Int) {}
}
- 协议继承
协议之间可以彼此继承,一个协议可以继承另一个协议.
protocol Runnable {
func run()
}
protocol Livable : Runnable {
func breath()
}
class Person : Livable {
func breath() {}
func run() {}
}
- 协议组合
协议组合,可以将协议和类组合起来(最多只能包含一个类类型)
protocol Livable {}
protocol Runnable {}
class Person {}
// 接收Person或者其子类的实例
func fn0(obj: Person) {}
// 接收遵守Livable协议的实例
func fn1(obj: Livable) {}
// 接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable & Runnable) {}
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn3(obj: Person & Livable & Runnable) {}
typealias RealPerson = Person & Livable & Runnable
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn4(obj: RealPerson) {}
注意: 只能用 & 组合协议,不能使用 | 组合协议,因为使用 | 组合还要单独区分具体是哪个类,这样做毫无意义.
一些常用协议
CaseIterable
让枚举遵守CaseIterable协议,可以实现遍历枚举值,CaseIterable协议源码如下:
public protocol CaseIterable {
/// A type that can represent a collection of all values of this type.
associatedtype AllCases : Collection where Self == Self.AllCases.Element
/// A collection of all values of this type.
static var allCases: Self.AllCases { get }
}
enum Season : CaseIterable {
case spring, summer, autumn, winter
}
let seasons = Season.allCases
print(seasons.count) // 4
for season in seasons {
print(season) // spring summer autumn winter
}
- CustomStringConvertible
遵守CustomStringConvertible、CustomDebugStringConvertible协议,都可以自定义实例的打印字符串,协议源码如下:
public protocol CustomStringConvertible {
var description: String { get }
}
public protocol CustomDebugStringConvertible {
var debugDescription: String { get }
}
class Person : CustomStringConvertible, CustomDebugStringConvertible {
var age = 0
var description: String { "person_\(age)" }
var debugDescription: String { "debug_person_\(age)" }
}
var person = Person()
print(person) // person_0
debugPrint(person) // debug_person_0
- print调用的是CustomStringConvertible协议的description
- debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription
类型相关关键字
- Any、AnyObject
Swift提供了两种特殊的类型:Any
、AnyObject
- Any:可以代表任意类型(枚举、结构体、类,也包括函数类型)
- AnyObject:可以代表任意类类型(在协议后面写上:
AnyObject
代表只有类能遵守这个协议,在协议后面写上:class
也代表只有类能遵守这个协议)
var stu: Any = 10
stu = "Jack"
stu = Student()
// 创建1个能存放任意类型的数组
// var data = Array<Any>()
var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Student())
data.append("Jack")
data.append({ 10 })
- is、as?、as!、as
- is用来判断是否为某种类型,
- as用来做强制类型转换
as?、as!、as的区别:
- as?和as!都代表可选类型
- as?表示可能强转成功也可能强转失败
- as!表示强转之后进行隐式解包
- 百分百可以强转成功就使用as
protocol Runnable { func run() }
class Person {}
class Student : Person, Runnable {
func run() {
print("Student run")
}
func study() {
print("Student study")
}
}
var stu: Any = 10
print(stu is Int) // true 是否是Int
stu = "Jack"
print(stu is String) // true 是否是String
stu = Student()
print(stu is Person) // true 是否是Person及其子类
print(stu is Student) // true 是否是Student及其子类
print(stu is Runnable) // true 是否是遵守Runnable协议的类
var stu: Any = 10
(stu as? Student)?.study() // 没有调用study
//第一个?代表强制转换可能成功可能失败,第二个?代表可选类型调用方法必须加?
stu = Student()
(stu as? Student)?.study() // Student study
(stu as! Student).study() // Student study
(stu as? Runnable)?.run() // Student run
var data = [Any]()
data.append(Int("123") as Any) //百分百可以转换成功就使用as
var d = 10 as Double //百分百可以转换成功就使用as
print(d) // 10.0
注意可选链:
(stu as? Student)?.study() 第一个?代表强制转换可能成功可能失败,第二个?代表可选类型调用方法必须加?
(stu as? Student)!.study()
(stu as! Student).study()
上面两种写法完全等价,都代表隐式解包,但是上面第二种两种写法有风险:一旦强制解包失败会报错
X.self. , X.Type , AnyClass(X
表示的是类)
- X.self是一个元类型(metadata)的指针,metadata存放着类型相关信息(就是以前我们说的,对象堆空间前8字节存放的类型相关的那个指针)
- X.self属于X.Type类型
- X.self有点类似于OC的X.class
- AnyObject代表任意类类型
- AnyClass就是AnyObject.Type,代表任意类的元类型
class Person {}
class Student : Person {
static var age = 0
}
var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
perType = Student.self //可以赋值
print(Person.self) //Person
print(Student.self) //Student
print(perType) //Person
print(stuType) //Student
var anyType: AnyObject.Type = Person.self
anyType = Student.self //可以赋值
print(anyType) //Person
print(anyType) //Person
public typealias AnyClass = AnyObject.Type //任意类的元类型
var anyType2: AnyClass = Person.self //可以赋值
anyType2 = Student.self //也可以赋值
var per1 = Person()
var per1Type = type(of: per1) //返回的就是Person.self
print(Person.self) //Person
print(type(of: per1)) //Person
print(type(of: per1) == Person.self) // true
如下所示代码:
class Person{
}
var p = Person()
它的内存分布如下:
全局变量p
存储的是Person
实例对象的前8个字节的地址.这8个字节就是Person
元类型地址.
X.self
:是一个元类型(metadata)
的地址,metadata
中存放的是类型相关的信息.
也就是说X.self
返回的是Person
实例对象的前8个字节中存放的内存地址,我们将通过汇编证明这一点.
汇编分析代码:
class Person{
}
var p = Person()
var personType = Person.self
汇编分析:
12 行加断点,再运行一遍
personType
中存放的内容和Person
对象的前8个字节的内容相同
补充1:下面两行完全一样
class Person {
static var age = 0
}
Person.age = 10 //通过类型访问age
Person.self.age = 10 //通过元类型访问age
补充2:type(of: per1) == Person.self
//接收一个实例,告诉你这个实例是什么类型,返回的是X.Type类型
//Swift把它定性为函数,但它本质不是函数调用,是直接取出per1对象的前8个字节赋值给左边
var per1Type = type(of: per1) //返回的就是Person.self
type(of:)
表面上看起来很像一个函数,但是我们窥探它的汇编发现它的本质就是直接取出实例对象的前8个字节,并没有函数调用
元类型的应用
- 根据元类型创建实例
X.self有点类似于OC的X.class
class Animal { required init() {} } //确保子类都有init()
class Cat : Animal {}
class Dog : Animal {}
class Pig : Animal {}
//传入元类型,创建出实例放到数组中返回
func create(_ clses: [Animal.Type]) -> [Animal] {
var arr = [Animal]()
for cls in clses {
arr.append(cls.init()) //元类型,调用init()
}
return arr
}
print(create([Cat.self, Dog.self, Pig.self]))
上面代码“arr.append(cls.init())”,通过元类型调用init(),和我们通常写的Animal()是一样的,如下:
//通过窥探汇编可知,下面几行完全一样的
var a1 = Animal()
var a2 = Animal.self()
var a3 = Animal.init()
var a4 = Animal.self.init()
//甚至:
var a5 = type(of:a2).init() //type(of:a2)就是拿到Animal.self
他们本质都是调用init()
Animal是类型,Animal.self是元类型,只不过很多时候Animal.self和Animal可以相互取代(如果要求传入的就是元类型就不能取代)
- Swift中使用Runtime的一些函数
Swift虽然没有Runtime,但是一些纯Swift的类也可以使用Runtime的一些函数,因为Swift实现了这些函数
import Foundation
class Person {
var age: Int = 0
}
class Student : Person {
var no: Int = 0
}
//至少占用多少字节
print(class_getInstanceSize(Student.self)) // 32
//获取父类
print(class_getSuperclass(Student.self)!) // Person
//获取父类
print(class_getSuperclass(Person.self)!) // Swift._SwiftObject
从结果可以看得出来,Swift还有个隐藏的基类:Swift._SwiftObject
可以参考Swift源码:https://github.com/apple/swift/blob/master/stdlib/public/runtime/SwiftObject.h
- Self
self代表方法调用者
Self代表当前类型
class Person {
var age = 1
static var count = 2
func run() {
print(self.age) // 1
print(Self.count) // 2
}
}
Self一般用作返回值类型,限定返回值跟方法调用者必须是同一类型(也可以作为参数类型)
protocol Runnable {
func test() -> Self //限定返回值跟方法调用者必须是同一类型
}
class Person : Runnable {
required init() {} //必须是required
func test() -> Self {
type(of: self).init() //使用元类型调用init()
}
}
class Student : Person {}
var p = Person()
// Person
print(p.test())
var stu = Student()
// Student
print(stu.test())
特别备注
本系列文章总结自MJ老师在腾讯课堂Swift编程从入门到精通-MJ大神精选,相关图片素材均取自课程中的课件。如有侵权,请联系我删除,谢谢!