Swift语法知识汇总(上)

导语

历时5年发展, 从swift1.x发展到了swift5.x版本, 经历了多次重大改变, ABI终于稳定.

API(Application Programming Interface): 应用程序编程接口
    源代码和库之间的接口
ABI(Application Binary Interface): 应用程序二进制接口
    应用程序与操作系统之间的底层接口
    设计的内容有: 目标文件格式(maco格式)、数据类型大小/布局/对齐,函数调用约定等等

随着ABI的稳定, swift语法基本不会再有太大的变动, 此时正在学习swift的最佳时刻

编译器分前端和后端:

1.前端: 语法分析...
2.后端:生成对应平台的二进制代码

编译流程:
OC
c --> (编译前端)clang --> (编译后端)LLVM IR 通过 LLVM compiler --->x86/ARM/other
Swift
Swift --> (编译前端) swiftc --> (编译后端)LLVM IR 通过 LLVM compiler --->x86/ARM/other

Swift编译大概流程:
Swift Code(swift代码) --> Swift AST(根据swiftc生成语法树) --> Raw Swift IL(swift特有中间代码) --> Canonical Swift IL(swift特有中间代码更简洁) --> LLVM IR(编译后端生成LLVM中间代码) --> Assembly(汇编代码) --> Executable(二进制代码)

swiftc

swiftc存放在Xcode内部
Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

一些操作
1.生成.swift文件的语法树
  命令行输入:cd (.swift所在文件目录)
  swiftc -dump-ast main.swift
2.生成最简洁的SIL代码: swiftc -emit-sil main.swift
3.生成LLVM IR代码: swiftc -emit-ir main.swift -o main.ll
4.生成汇编代码: swiftc -emit-assembly main.swift -o main.s

对汇编代码进行分析, 可以真正掌握编程语言本质

断点后,转汇编代码查看: Debug >> Debug Workflow >> AlwaysShow Dissassembly(永远显示反汇编,就是把你平时写的代码转换成汇编代码)

第一章 基本运算、流程控制、函数**

1. Hello World

1.不用编写main函数, Swift将全局范围内的首句可执行代码作为程序入口
2.一句代码尾部可以省略分号(;), 多句代码写到同一行时必须用分号(;)隔开
3.用var定义变量, let定义常量, 编译器能自动推断出变量/常量的类型
4.Playground可以快速预览代码效果,是学习语法的好帮手

快捷键:
Command + Shift + Enter: 运行整个Playground

var a = 10
print("Hello Wrold! - \(a)")//拼接字符串

2. Playground

快捷键:
Command + 1 显示左测文件栏
Command + 0 隐藏左侧文件栏
Command + N 新建代码文件page页

import UIKit
import PlaygroundSupport

//使用Playground展示一个view
let view = UIView()
view.frame = CGRect(x: 0, y: 0, width: 100, height: 100)
view.backgroundColor = UIColor.red
PlaygroundPage.current.liveView = view

//使用Playground展示一个图片
let imageView = UIImageView(image: UIImage(name: "logo"))
PlaygroundPage.current.liveView = imageView

//使用Playground展示一个视图控制器
let vc = UITableViewController()
vc.view.backgroundColor = UIColor.lightGray
PlaygroundPage.current.liveView = vc

//Playground--多Page
File >> New >> Playground Page

3. 注释

0. Swift支持注释嵌套

// 单行注释

/*
多行注释
*/

/*
1
// 多行注释嵌套单行注释
/* 多行注释嵌套多行注释 */
2
*/

1.Playground的注释支持markup语法(与markdown类似) //: 或 /*:*/
    单行markup:
    编写markup语法 //: # 一级标题

    多行markup:
    编写markup语法
    /*:
            # 学习Swift
            ## 基础语法
            - 变量
            - 常量
            ## 面向对象
            - 类
            - 属性
    */
    运行markup语法 Editor >> Show Rendered Markup

4. 常量

// 只能赋值1次
// 它的值不要求在编译时期确定, 在运行时确定也可以, 但使用之前必须赋值1次
let age1 = 10

let age2: Int //这种写法,必须说明类型
age2 = 20

func getAge() -> Int {
  return 30
}
let age3 = getAge()//在运行时确认值

// 常量、变量在初始化之前, 都不能被使用, 否则会报错
let age: Int
var height: Int
print(age)//报错
print(height)//报错

5. 标识符_数据类型

// 标识符(比如常量名、变量名、函数名)几乎可以使用任何字符
// 标识符不能以数字开头, 不能包含空白字符、制表符、箭头等特殊字符

常见的数据类型:

Swift常见数据类型.png

整数类型: Int8、Int16、Int32、Int64、UInt8、UInt16、UInt32、UInt64
在32bit平台, Int等价于Int32, 在64bit平台, Int等价于Int64
整数的最值: UInt8.max、Int16.min
一般情况下, 都是直接使用Int即可

浮点类型:Float, 32位, 精度只有6位; Double, 64位, 精度至少15位.

6. 字面量

// 布尔
let bool = true // 取反是false

// 字符串
let string = "小哥哥"

// 字符 (可存储ASCII字符、Unicode字符)
let character: Character = ""

// 整数
let intDecimal = 17 //十进制
let intBinary = 0b10001 //二进制
let intOctal = 0o21 // 八进制
let intHexadecimal = 0x11 //十六进制

// 浮点数
let doubleDecimal = 125.0 //十进制,等价于1.25e2,  0.0125等价于1.25e-2
let doubleHexadecimal1 = 0xFp2//十六进制, 意味着15x(2^2), 相当于十进制的60.0
let doubleHexadecimal2 = 0xFp-2//十六进制,意味着15x(2^-2),相当于十进制的3.75
//以下都是表示12.1875
//十进制:12.1875、1.21875e1
//十六进制: 0xC.3p0

// 整数和浮点数可以添加额外的零或者添加下划线来增强可读性
    比如: 100_0000、1_000_000.000_000_1、000123.456

// 数组
let array = [1,3,5,7,9]

// 字典
let dictionary = ["age" : 18, "height" : 165]

7. 类型转换

// 整数转换
let int1: UInt16 = 2_000
let int2: UInt8 = 1
let int3 = int1 + UInt16(int2)

// 整数、浮点数转换
let int = 3
let double = 0.14159
let pi = Double(int) + double
let intPi = Int(pi)

// 字面量可以直接相加, 因为数字字面量本身没有明确的类型
let result = 3 + 0.14159

8. 元组(tuple)

let http404Error = (404, "Not Found") //将多种类型组合在一起, 赋值给元祖对象
print("The status code is \(http404Error.0)")

let(statusCode, statusMessage) = http404Error //接收元祖
print("The status code is \(statusCode)")

let(justTheStatusCode, _) = http404Error //不想接收的值,用_占位

let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")

第二章 if-else和while、区间、Switch、函数

1、if-else 和 while

// 1.if-else
/*
  if后面的条件可以省略小括号;
  条件后面的大括号不可以省略;
  if后面的条件只能是Bool类型;
*/

// 2.while
/*
  repeat-while相当于C语言中的do-while;
  这里不用num--,是因为从Swift3开始,去除了自增(++)、自减(--)运算符
*/
var num = 5
while num > 0{
  print("num is \(num)")
  num -= 1
}//打印了5次

var num = -1
repeat {
  print("num is \(num)")
}while num > 0 //打印了1次

2-1、区间

// 闭区间运算符: a...b 其实就是 a <= 取值 <= b 
let names = ["a","b","c","d"]
for i in 0...3 {
  print(name[I])
}// a b c d

for name in names[0...3]{// for-区间运算符用在数组上
  print(name)
}// a b c d

let range = 1...3
for i in range {
  print(name[I])
}// b c d

let a = 1
let b = 2
for i in a...b{// 可以用变量来作为区间
  print(name[I])
}// b c
for i in a...3{
  print(name[I])
}// b c d

for var i in 1...3{// i 默认是let, 有需要时可以声明为var
  i += 5
  print(i)
}//6 7 8

for _ in 1...3 {// 如果用不到i, 用_占位
  print("for")
}//打印了3次

2-2、半开区间运算符: a..

for i in 1..<5 {
  print(i)
}//1 2 3 4

2-3、单侧区间: 让区间朝一个方向尽可能的远

for name in names[2...] {
  print(name)
}// c d

for name in names[...2] {
  print(name)
}// a b c

for name in names[..<2] {
  print(name)
}// a b

let range = ...5
range.contains(7)//false
range.contains(4)//true
range.contains(-3)//true

2-4、区间类型

let range1: ClosedRange = 1...3
let range2: Range = 1..<3
let range3: PartialRangeThrough = ...5

//字符、字符串也能使用区间运算符, 但默认不能用在for-in中
let stringRange1 = "cc"..."ff" //CloseRange
stringRange1.contains("cb")//false
stringRange1.contains("dz")//true
stringRange1.contains("fg")//false

let stringRange2 = "a"..."f"
stringRange2.contains("d")//true
stringRange2.contains("h")//false

// \0到~囊括了所有可能要用到的ASCII字符
let characterRange: CloseRange = "\0"..."~"
characterRange.contains("G")//true

2-5、带间隔的区间值

let hours = 11
let hourInterval = 2
// tickMark的取值: 从4开始, 累加2, 不超过11
for tickMark in stride(from: 4, through: hours, by: hourInterval){
  print(tickMark)
}// 4 6 8 10

3、switch

/*
    case、default后面不能写大括号{} ;
    默认可以不写break, 并不会贯穿到后面的条件;
    使用fallthrough可以实现贯穿效果;
    switch必须要保证能处理所有情况, 否则会报错;
    case、default后面至少要有一条语句, 如果不想做任何事, 加个break即可;
*/
var number = 1
switch number {
  case 1:
    print("number is 1")
    break
  case 2:
    print("number is 2")
    break
  default:
    print("number is other")
    break
}// number is 1

switch number {//默认可以不写break, 并不会贯穿到后面的条件
  case 1:
    print("number is 1")
    fallthrough//使用fallthrough可以实现贯穿效果
  case 2:
    print("number is 2")
  default:
    break//case、default后面至少要有一条语句;
}// number is 1  \n number is 2

/*
    switch注意点:
        如果能保证已处理所有情况, 也可以不必使用default;
*/
enum Answer {case right, wrong}
let answer = Answer.right
switch answer {
  case Answer.right:
    print("right")
  case Answer.wrong:
    print("wrong")
}

switch answer {//由于已确定answer是Answer类型, 因此可以省略Answer
  case .right:
    print("right")
  case .wrong:
    print("wrong")
}

3-1、复合条件

//switch也支持Character、String类型
let string = "Jack"
switch string {
  case "Jack", "Rouse"://满足其中一个条件就执行
    print("Right person")
  default:
    break
}//Right person

3-2、区间匹配、元组匹配

//可以使用下划线_忽略某个值
//关于case匹配问题, 属于模式匹配的范畴,以后会再次详细展开讲解
let count = 62
switch count {
  case 0:
    print("none")
  case 1..<5: //区间匹配
    print("a few")
  case 5..<12:
    print("several")
  case 12..<100:
    print("dozens of")
  case 100..<1000:
    print("hundreds of")
  default:
    print("many")
}// dozens of

let point = (1, 1)
switch point {
  case (0, 0)://元组匹配
    print("the origin")
  case (_,0):
    print("on the x-axis")
  case (0,_):
    print("on the y-axis")
  case (-2...2, -2...2):
    print("inside the box")
  default:
    print("outside of the box")
}// inside the box

3-3、值绑定

let point = (2, 0)
switch point {
  case(let x, 0):
    print("on the x-axis with an x value of \(x)")
  case(0, let y):
    print("on the y-axis with an y value of \(y)")
  case let(x, y):
    print("somewhere else at (\(x), \(y))")
}// on the x-axis with an x value of 2

3-4、where--过滤不满足条件的信息

let point = (1, -1)
switch point {
  case let (x,y) where x==y: //值绑定后,加条件
    print("on the line x==y")
  case let (x,y) where x==-y:
    print("on the line x==-y")
  case let (x,y):
    print("(\(x), \(y)) is just some arbitrary point")
}// on the line x == -y

//将所有正数加起来
var numbers = [10,20,-10,-20,30,-30]
var sum = 0
for num in numbers where num > 0 {//使用where来过滤num
  sum += num
}
print(sum) //60

3-5、标签语句

outer: for i in 1...4 {// 如果现在内层嵌套的for循环里面写continue和break想控制外面的for循环,那么加上outer标签就好了
  for k in 1...4 {
    if k==3 {
      continue outer
    }
    if i==3 {
      break outer
    }
    print("i == \(i), k == \(k)")
  }
}

4、函数

func pi() -> Double {//不带参数, 有返回值
  return 3.14
}

func sum(v1: Int, v2: Int) -> Int {//带参数, 有返回值
  return v1 + v2
}
sum(v1: 10,v2: 20)
// 形参默认是let, 也只能是let

func sayHello() -> Void {//写法一:无返回值
  print("Hello")
}
func sayHello() -> () {//写法二:无返回值, 小括号代表空元组
  print("Hello")
}
func sayHello() {//写法三:无返回值
  print("Hello")
}

4-1、隐式返回(Implicit Return)

//如果整个函数体是一个单一表达式,那么函数会隐式返回这个表达式
  func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
  }
  sum(v1: 10, v2: 20)// 30

4-2、返回元组: 实现多返回值

func calculate(v1: Int, v2: Int) -> (sum:Int, difference: Int, average: Int){
  let sum = v1 + v2
  return (sum, v1 - v2, sum >> 1)
}
let result = calculate(v1: 20, v2: 10)
result.sum //30
result.difference //10
result.average //15

4-3、函数的文档注释

/// 求和[概述]
///
/// 将两个整数相加[更详细的描述]
///
/// - Parameter v1: 第1个整数
/// - Parameter v2: 第2个整数
/// - Returns: 2个整数的和
///
/// - Note:传入两个整数即可[批注]
///
func sum(v1: Int, v2: Int) -> Int {
  v1 + v2
}
// option + command + / 快速注释快捷键
// 参考: https://swift.org/documentation/api-design-guidelines/

4-4、参数标签(Argument Label)

//可以修改参数标签
func goToWork(at time:String) {//调用时at替代time作为参数名
  print("this time is \(time)")
}
goToWork(at: "00:00")//this time is 00:00

//可以使用下划线_ 省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
  v1 + v2
}
sum(10, 20)

4-5、默认参数值(Default Parameter Value)

//参数可以有默认值
func check(name: String = "nobody", age: Int, job: String = "none"){
  print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack")
check(age: 10)
//C++的默认参数值有个限制: 必须从右往左设置. 由于Swift拥有参数标签, 因此并没有此类限制
//但是在省略参数标签时, 需要特别注意, 避免出错

4-6、可变参数

fuc sum(_ numbers:Int...) -> Int {//...代表可变参数,意味着可以传很多个Int参数
  var total = 0
  for number in numbers {//numbers暂且认定为数组
    total += number
  }
  return total
}
sum(10, 20, 30, 40)//100
// 一个函数最多只能有1个可变参数
// 紧跟在可变参数后面的参数不能用省略参数标签
func test(_ numbers: Int..., string: String, _ other String){}
test(10, 20, 30, string: "Jack", "Rose")

4-7、输入输出参数(In-Out Parameter)

// 可以用inout定义一个输入输出参数: 可以在函数内部修改外部实参的值
func swapValues(_ v1: inout Int, _ v2: inout Int) {
  let tmp = v1
  v1 = v2
  v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)

func swapValues(_ v1: inout Int, _ v2: inout Int) {//交换两个外部变量的值
  (v1, v2) = (v2, v1)//用元组进行交换
}
// 可变参数不能标记为inout
// inout参数不能有默认值
// 示例代码中inout参数的本质是地址传递(引用传递), 如果传递给inout参数的是计算属性、有监听器的属性等内容,其本质并非引用传递,在[属性]章节再作详细讲解
// inout参数只能传入可以被多次赋值的,也就是说调用时传入v1和v2的,是可以被多次赋值的变量var

4-8、函数重载(Function Overload)

//规则: 函数名相同; 参数个数不同||参数类型不同||参数标签不同
func sum(v1: Int, v2: Int) -> Int {
  v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int) -> Int {
  v1 + v2 + v3
}// 参数个数不同
func sum(v1: Double, v2: Int) -> Double {
  v1 + Double(v2)
}// 参数类型不同
func sum(a: Int, b: Int) -> Int {
  a + b
}//参数标签不同
sum(v1: 10, v2: 20)//30
sum(v1: 10, v2: 20, v3: 30)//60
sum(v1: 10.0, v2: 20)//30.0
sum(a: 10, b: 20)//30
/*函数重载注意点:
  1.返回值类型与函数重载无关;
  2.默认参数值和参数重载一起使用产生二义性时,编译器并不会报错(在C++中会报错);
  3.可变参数、省略参数标签、函数重载一起使用产生二义性时,编译器有可能会报错
*/

4-9、内联函数(Inline Function)

//如果开启了编译器优化(Release模式默认会开启优化), 编译器会自动将某些函数变成内联函数.
//开启:Build Settings >> Swift Compiler - Code Generation >> Optimization Level >> Debug   Optimize for Speed[-O]
//内联函数实质: 将函数调用展开成函数体
//哪些函数不会被内联? 1.函数体比较长的时候 2.包含递归调用 3.包含动态派发(动态绑定)
@inline(never) func test(){//永远不会被内联(即使开启了编译器优化)
  print("test")
}
@inline(__always) func test() {//开启编译器优化后, 即使代码很长,也会被内联(递归调用很熟,动态派发的函数除外)
  print("test")
}
//在Release模式下,编译器已经开启优化,会自动决定哪些函数需要内联,因此没必要使用@inline

4-10、函数类型(Function Type)

//每一个函数都有类型的, 函数类型由形式参数类型、返回值类型组成
func test(){ }// () -> Void 或者 () -> ()

func sum(a:Int, b:Int) -> Int{
  a + b
}// (Int, Int) -> Int
//定义变量
var fn: (Int, Int) -> Int = sum
fn(2, 3) //5 调用时不需要参数标签

//函数类型作为函数参数
func sum(v1: Int, v2: Int) -> Int {
  v1 + v2
}
func difference(v1: Int, v2: Int) -> Int {
  v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
  print("Result:\(mathFn(a, b))")
}
printResult(sum, 5, 2) // Result:7
printResult(difference, 5, 2) // Result:3

//函数类型作为函数返回值
func next(_ input: Int) -> Int {
  input + 1
}
func previous(_ input: Int) -> Int {
  input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int {
  forward? next : previous
}
forward(true)(3) //4
forward(false)(3)//2  //每一个函数都有类型的, 函数类型由形式参数类型、返回值类型组成
func test(){ }// () -> Void 或者 () -> ()

func sum(a:Int, b:Int) -> Int{
  a + b
}// (Int, Int) -> Int
//定义变量
var fn: (Int, Int) -> Int = sum
fn(2, 3) //5 调用时不需要参数标签

//函数类型作为函数参数
func sum(v1: Int, v2: Int) -> Int {
  v1 + v2
}
func difference(v1: Int, v2: Int) -> Int {
  v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
  print("Result:\(mathFn(a, b))")
}
printResult(sum, 5, 2) // Result:7
printResult(difference, 5, 2) // Result:3

//函数类型作为函数返回值
func next(_ input: Int) -> Int {
  input + 1
}
func previous(_ input: Int) -> Int {
  input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int {
  forward? next : previous
}
forward(true)(3) //4
forward(false)(3)//2

4-11、typealias用来给类型起别名

typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64

typealias Date = (year: Int, month:Int, day:Int)//用Date代替这个元组
func test(_ date: Date) {
  print(date.0)
  print(date.year)
}
test((2011, 9, 10))

typealias IntFn = (Int, Int) -> Int //用IntFn代替这种函数类型
func difference(v1: Int, v2: Int) -> Int {
  v1 - v2
}
let fn: IntFn = difference
fn(20, 10)//10
func setFn(_ fn: IntFn){ }
setFn(difference)
func getFn() -> IntFn { difference }

//按照Swift标准库的定义, Void就是空元组()
public typealias Void = ()

4-12、嵌套函数(Nested Function)

//将函数定义在函数内部
func forward(_ forward: Bool) -> (Int) -> Int {
  func next(_ input: Int) -> Int {
    input + 1
  }
  func previous(_ input: Int) -> Int {
    input - 1
  }
  return forward ? next : previous
}
forward(true)(3)//4
forward(false)(3)//2

第三章 枚举

1-1、枚举的基本用法

enum Direction {//定义方式一
  case north
  case south
  case east
  case west
}
enum Direction {//定义方式二
  case north, south, east, west
}

var dir = Direction.west //使用方式一
dir = Direction.east
dir = .north
print(dir) // north

switch Direction {//使用方式二
  case .north
    print("north")
  case .south
    print("south")
  case .east
    print("east")
  case .west
    print("west")
}

1-2、关联值(Associated Values)

//有时会将枚举的成员值跟其他类型的关联存储在一起,会非常有用
enum Score { //示例一
  case points(Int)
  case grade(Character)
}
var score = Score.points(96)
score = .grade("A")
switch score {
  case let .points(i):
    print(i,"points")
  case let .grade(i):
    print("grade", i)
}// grade A

enum Date {//示例二
  case digit(year: Int, month: Int, day: Int)
  case string(String)
}
var date = Date.digit(year: 2011 month: 9, day:10)
date = .string("2011-09-10")
switch date {
  case .digit(let year, let month, let day):
    print(year, month, day)
  case let .string(value):
    print(value)
}

1-3、原始值(Raw Values)

// 枚举成员可以使用相同类型的默认值预先关联, 这个默认值叫做: 原始值
enum PokerSuit : Character {
  case spade = "♠"
  case heart = "♥"
  case diamond = "♦"
  case club = "♣"
}
var suit = PokerSuit.spade
print(suit) //spade
print(suit.rawValue)//♠
print(PokerSuit.club.rawValue)// ♣

enum Grade: String {//枚举Grade关联的原始值是String类型
        case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect.rawValue) // A
print(Grade.great.rawValue) // B
print(Grade.good.rawValue) // C
print(Grade.bad.rawValue) // D

1-4、隐式原始值(Implicitly Assigned Raw Values)

//如果枚举的原始值类型是Int、String, Swift会自动分配原始值
enum Direction : String {
  case north = "north"
  case south = "south"
  case east = "east"
  case west = "west"
}
enum Direction: String {//等价于
  case north, south, east, west
}
print(Direction.north) //north
print(Direction.north.rawValue) //north

enum Season : Int { //自动递增
  case spring, summer, autumn, winter
}
print(Season.spring.rawValue) //0
print(Season.summer.rawValue) //1
print(Season.autumn.rawValue) //2
print(Season.winter.rawValue) //3

enum Season : Int { //自动递增
  case spring = 1, summer, autumn = 4, winter
}
print(Season.spring.rawValue) //1
print(Season.summer.rawValue) //2
print(Season.autumn.rawValue) //4
print(Season.winter.rawValue) //5

1-5、递归枚举

//定义一个枚举类型,枚举的成员里面的关联值也用到了这个枚举类型,就是递归枚举.必须加关键字indirect
indirect enum ArithExpr {//递归枚举写法一(多用)
  case number(Int)
  case sum(ArithExpr, ArithExpr)
  case difference(ArithExpr, ArithExpr)
}
enum ArithExpr {//递归枚举写法二
  case number(Int)
  indirect case sum(ArithExpr, ArithExpr)
  indirect case difference(ArithExpr, ArithExpr)
}

let five = ArithExpr.number(5)//获取枚举成员变量
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, two)

func calculate(_ expr: ArithExpr) -> Int {
  switch expr {
    case let .number(value):
        return value
    case let .sum(left, right):
        return calculate(left) + calculate(right)
    case let .difference(left, right):
        return calculate(left) - calculate(right)
  }
}
calculate(difference)//使用递归枚举

2、MemoryLayout

可以使用MemoryLayout获取数据类型所占用的内存大小
var age = 10
//使用方法一: MemoryLayout支持泛型
MemoryLayout.size //占8个字节数(分配占用的空间大小)
MemoryLayout.stride //占8个字节(实际用到的空间大小)
MemoryLayout.alignment //(alignment:内存对齐参数),占用8个字节

//使用方法二:
MemoryLayout.size(ofValue: age)
MemoryLayout.stride(ofValue: age)
MemoryLayout.alignment(ofValue: age)

// 可以使用MemoryLayout获取数据类型占用的内存大小
enum Password {
  case number(Int, Int, Int, Int) //此处是关联值,关联值存储在枚举变量内存中,所以在枚举变量内存中占用4(关联值)*8(每个int类型占8个字节)=32个字节
  case other //只占用1个字节
}
var pwd = Password.number(5, 6, 4, 7) // 分配40个字节, 实际占用33 
pwd = .other // 分配40个字节, 实际占用33 

MemoryLayout.stride // 40 (分配占用的空间大小)
MemoryLayout.size // 33 (实际用到的空间大小)
MemoryLayout.alignment // 8 (对齐参数,此时要求分配空间是8的倍数, 不够8的倍数要补齐)

enum Season {
  case spring = 1, summer, autumn, winter //此处是原始值,没有存储到枚举变量内存中, 底层只存储了1个字节来区分变量
}
MemoryLayout.size //1
MemoryLayout.stride //1
MemoryLayout.alignment//1
/*为什么是1个字节? 
是因为关联值与原始值的区别: 
原始值(定义成员的时候就给它一个默认值),原始值会永远跟你的成员保存在一起,原始值是固定死的,不允许传值; 
关联值的特点是允许自己传入不同的值进来.
*/

// Int类型占用8个字节, string类型占用16个字节.

/*关联值和原始值的区别:
关联值是 枚举的成员和成员自己的其他类型数据关联到一起存储的.
原始值是 在枚举定义成员的时候就给它一个默认值.
如果是关联值, 是将传过来的值, 直接存储到枚举变量的内存中. 每一个枚举变量都要有自己的内存来存储这些值.
原始值是固定死的, 跟自己的成员固定绑定在一起, 不允许自定义. 没有存储在枚举变量中.

那么原始值存储在哪里? 完全可以不存, 比如:
enum Season : Int {
  // 0 1 2 3
  case spring = 1, summer, autumn, winter
  func rawValue()-> Int {
    if self == 0 return 1
    if self == 1 return 2
    ...
  }
}
*/
总结: 
如果枚举变量是关联值,到时候可以传入一个具体的值和枚举进行关联,那么传进去的这些值是直接存储到枚举变量内存里面; 
如果枚举类型写个:Int之类的什么类型的,叫做原始值,原始值是跟每一个成员是固定绑在一起的, 但是这些原始值是不会占用你的枚举变量的内存的, 相当于我们的原始值不是存储在枚举变量的内存里面的.

3、可选项(Optional)

//可选项, 一般也叫可选类型, 它允许将值设置为nil
//在类型名称后面加个?来定义一个可选项
var name: String? = "Jack"//默认情况下是不允许你给空值的,只有设置为可选项才可以设置为nil
name = nil

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

var array = [1, 15, 40, 29]
func get(_ index: Int) -> Int? {//表明可以返回nil或Int类型
  if(index < 0 || index >= array.count){
    return nil
  }
  return array[index]
}

print(get(1)) // Optional(15)
print(get(-1))// nil
print(get(4))// nil

3-1、强制解包(Forced Unwrapping)

/*
    可选项是对其他类型的一层包装, 可以将它理解为一个盒子,
    如果为nil, 那么它是个空盒子,
    如果不为nil, 那么盒子里装的是: 被包装类型的数据;
    如果要从可选项中取出被包装的数据(将盒子里装的东西取出来), 需要使用感叹号!进行强制解包.
*/
var age: Int? = 10
let ageInt: Int = age!
ageInt += 10
//如果对值nil的可选项(空盒子)进行解包, 将会产生运行时错误. 所以强制解包时一定要确认它不是nil

3-2、判断可选值是否包含值

let number = Int("123")
if number != nil {
   print("字符串转换整数成功:\(number!)")
}else{
  print("字符串转换整数失败")
}// 字符串转换整数成功:123

3-3、可选项绑定(Optional Binding)

// 可以使用可选项绑定来判断可选项是否包含值
// 如果包含就自动解包,把值赋给一个临时的常量(let)或者变量(var),并返回true,否则返回false
if let number = Int("123") {
  print("字符串转换成功:\(number)")
  // number是强制解包之后的Int值
  // number作用域仅限于这个大括号
}else{
  print("字符串转换整数失败")
}// 字符串转换整数成功:123

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("\(first) < \(second) < 100")
}// 4 < 42 < 100

3-4、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)//30

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

public func ?? (optional:T?,defaultValue: @autoclosure() throws -> T?) rethrows -> T?
public func ?? (optional:T?,defaultValue: @autoclosure() throws -> T) rethrows -> T

a ?? b //a是可选项,??左边必须放可选项; b是可选项或者不是可选项; b跟a的存储类型必须相同; 作用:如果a不为nil,就返回a,此时如果b不是可选项,返回a时会自动解包;如果a为nil,就返回b,

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

let a: Int? = nil
let b: Int? = 2
let c = a ?? b // c是Int? ,Optional(2)

let a: Int? = nil
let b: Int? = nil
let c = a ?? b // c是Int? ,nil

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 : Int
if let tmp = a {
  c = tmp
}else {
  c = b
}

// 多个 ?? 一起使用
let a: Int? = 1
let b: Int? = 2
let c = a ?? b ?? 3 // c是Int , 1 , c是什么类型要看最后一个运算符是什么类型.

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

3-6、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
  }
  // if username ....
  // if password ....
  print("用户名:\(username)","密码:\(password)","登录ing")
}

login(["username" : "jack","password":"123456"])//用户名:jack 密码:123456 登录ing
login(["password":"123456"])// 请输入用户名
login(["username" : "jack"])// 请输入密码

3-7、字典和数组的元素的返回值类型

var dict = ["age":10]
var age = dict["abc"]// Int?  字典返回可选类型

var array = [1,2,3]
var num = array[-1]// Int 数组直接返回值, 需要自己检查数组越界

3-8、guard语句

guard 条件 else {
    //do something...
  退出当前作用域
  //return、break、continue、throw、error
}

//当guard语句的条件为false时, 就会执行大括号里的代码;
//当guard语句的条件为true时, 就会跳过guard语句
//guard语句特别适合用来"提前退出"
//当使用guard语句进行可选项绑定时,绑定的常量(let)、变量(var)也能在外层作用域中使用

//用guard简写3-7的登录逻辑:
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")
}
login(["username" : "jack","password":"123456"])//用户名:jack 密码:123456 登录ing
login(["password":"123456"])// 请输入用户名
login(["username" : "jack"])// 请输入密码

3-9、隐式解包(Implicitly Unwrapped Optional)

// 在某些情况下, 可选项一旦被设定值之后, 就会一直拥有值
// 在这种情况下, 可以去掉检查, 也不必每次访问的时候都进行解包, 因为它能够确定每次访问的时候都有值
// 可以在类型后面加个感叹号 ! 定义一个隐式解包的可选项
let num1: Int! = 10 // 隐式解包的可选项(自动解包), 等价于:let num2: Int = num1!
let num2: Int = num1
if num1 != nil {
    print(num1 + 6)// 16
}
if let num3 = num1 {
    print(num3)// 10
}

/// 如果可选项是空值那么会报错
let num1: Int! = nil
let num2: Int = num1// Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value: file MyPlayground.playground, line 

3-10、字符串插值

// 字符串插值
// 可选项在字符串插值或者直接打印时, 编译器会发出警告
var age: Int? = 10
print("My age is \(age)")//My age is Optional(10)

// 至少有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

3-11、多重可选项

var num1: Int? = 10 //包装了一个Int类型的可选类型盒子
var num2: Int?? = num1 // 包装了一个可选类型的可选类型盒子
var num3: Int?? = 10
print(num2 == num3) // true

var aum1: Int? = nil
var aum2: Int?? = aum1
var aum3: Int?? = nil
print(aum2 == aum3) // false

(aum2 ?? 1) ?? 2 // 2
(aum3 ?? 1) ?? 2 // 1

/*
可以使用lldb指令: help frame 查看frame有哪些指令
查看内存布局:
frame variable -R 或者 fr v -R 查看内存布局的区别
比如:fr v -R aum1
*/ 

3-12、思考下面枚举变量的内存布局

enum TestEnum {
    case test1, test2, test3
}
// 1个字节存储成员值
// N个字节存储关联值(N取占用内存最大的关联值), 任何一个case的关联值都共用这N个字节
// 共用体

// 有时候会将枚举的成员值跟其他类型的值关联存储在一起, 会非常有用

//枚举总共能存放256个字节 0x00~0xFF

var t = TestEnum.test1 //0
t = .test2 //1
t = .test3 //2

print(MemoryLayout.size)
print(MemoryLayout.stride)
print(MemoryLayout.alignment)

// 查看变量内存存储情况
// 打断点: Debug >> Debug Workflow >>View Memory  或者右键选择 View Memory of "xxx"

第四章 汇编分析枚举的内存布局

1-1、程序的本质

软件/程序的执行过程:
    (硬盘)程序/软件-->(装载)内存--->(读写)--->CPU-->(控制)计算机

CPU中分为:
    寄存器 --> 用来做:信息存储    
    运算器 --> 用来做:信息处理
    控制器 

通常, CPU会先将内存中的数据存储到寄存器中, 然后再对寄存器中的数据进行运算

假设内存中有块红色内存空间的值是3,现在想把它的值加1, 并将结果存储到蓝色内存空间
    1.CPU首先会将红色内存空间的值放到rax寄存器中: movq 红色内存空间, %rax  //movq是将左边的值送给到右边
    2.然后让rax寄存器与1相加: addq $0x1, %rax
    3.最后将值赋值给内存空间: movq %rax, 蓝色内存空间

CPU规定:
    1.不允许内存间直接交互数据,必须要通过CPU的寄存器 
    2.想做运算或计算也要拉倒CPU的寄存器中进行运算, 运算结束后再送回内存

1-2、汇编语言的发展

机器语言
    由0-1组成
汇编语言(Assembly Language)
    用符号代替0和1, 比机器语言便于阅读和记忆
高级语言
    C/C++/JavaScript/Python等, 更接近人类自然语言

操作: 将寄存器BX的内容送入寄存器AX
    机器语言: 1000100111011000
    汇编语言: movm %bx, %ax
    高级语言: ax = bx; //这里只是举例,高级语言不能直接操作寄存器.

高级语言-->(编译)汇编语言<-->(编译/反编译)机器语言-->(运行)计算机

汇编语言与机器语言一一对应, 每一条机器指令都有与之对应的汇编指令;
汇编语言可以通过编译得到机器语言, 机器语言可以通过反汇编得到汇编语言;
高级语言可以通过编译得到汇编语言/机器语言, 但汇编语言/机器语言几乎不可能

1-3、汇编语言的种类

汇编语言严重依赖于电脑硬件设备, 相当于CPU的架构不同用的汇编就不同, 种类有:
    8086汇编(16bit) //2个字节
    x86汇编(32bit) //4个字节
    x64汇编(64bit) //8个字节
    ARM汇编(嵌入式、移动设备)
    ...

x86、x64汇编根据编译器的不同, 有2种书写格式:
    Intel: Windows派系
    AT&T:   Unix派系

作为iOS开发工程师, 最主要的汇编语言是
    AT&T汇编 --> iOS模拟器
    ARM汇编   --> iOS真机设备

1-4、常见的汇编指令

项目	AT&T	Intel	说明
寄存器命名	%rax	rax
操作数顺序	movq %rax, %rdx	mov rdx, rax	将rax的值赋值给rdx
常数/立即数	movq 0x10, %rax	mov rax 3 mov rax, 0x10	将3赋值给rax 将0x10赋值给rax
内存赋值	movq $0xa, 0x1ff7(%rip)	mov qword ptr [rip+0x1ff7], 0xa	将0xa赋值给地址为rip + 0x1ff7的内存空间
取内存地址	leaq -0x18(%rbp), %rax	lea rax, [rbp - 0x18]	将rbp - 0x18这个地址赋值给rax
jmp指令	jmp *%rdx jmp 0x4001002 jmp *(%rax)	jmp rdx jmp 0x4001002 jmp [rax]	call和jmp写法类似,区别: jmp是跳转到某个地址去执行代码,一直到结束; 而call是跳到这个地址(call后面跟的一般是函数地址)去执行代码,然后配合ret(return)来配合使用
操作数长度	movl %eax, %edx movb $0x10, %al leaw 0x10(%dx), %ax	mov edx, eax mov al, 0x10 lea ax, [dx + 0x10]	b = byte(8-bit) s = short(16-bit integer or 32-bit floating point) w = word(16-bit) i = long(32-bit integer or 64-bit floating point) q = quad(64 bit) t = ten bytes(80-bit flating point)

备注: rip储存的是指令地址: 即CPU要执行的下一条指令地址就存储在rip中. rip += 正在执行指令的长度

1-5、寄存器

有16个常用的寄存器
    %rax、%rbx、%rcx、%rdx、%rsi、%rbp、%rsp
    %r8、%r9、%r10、%r11、%r12、%r13、%r14、%r15

寄存器的具体用途
    %rax、rdx常用作为函数返回值使用
    %rdi、%rsi、%rdx、%rcx、%r8、%r9等寄存器常用于存放函数参数
    %rsp、%rbp用于栈操作
    rip作为指令指针
        存储着CPU下一条要执行的指令的地址
        一旦CPU读取一条指令,rip会自动指向下一条指令(存储下一套指令的地址)

r开头: 64bit的寄存器, 只有8个字节
e开头: 32bit的寄存器, 占4个字节
ax,bx,cx : 16bit的寄存器, 占2个字节
ah al bh bl: 占1个字节

问: 64位的结构体怎么存储大于8个字节的数据呢,比如结构体对象?
答: 对象存在内存中,结构体不能塞到寄存器里面去的,它就是放在内存中

1-6、lldb常用指令

读取寄存器的值:
    register read/格式
        register read/x

修改寄存器的值:
    register write 寄存器名称 数值
        register write  rax 0

读取内存中的值:
    x/数量-格式-字节大小 内存地址
        x/3xw 0x0000010

修改内存中的值
    memory write 内存地址 数值
        memory write 0x0000010 10

格式
    x是16进制, f是浮点型, d是十进制

字节大小
    b - byte 1字节
    h - half word 2字节
    w - word 4字节
    g - giant word 8字节

express表达式
    可以简写: expr表达式
    expression $rax
    expression $rax = 1

po 表达式
point 表达式
    po/x(格式) $rax

thread step-over、next、n
    单步运行, 把子函数当做整体一步执行(源码级别)
thread step-in、step、s
    单步运行, 遇到子函数会进入子函数(源码级别)
thread step-inst-over、next、ni
    单步运行,把子函数当做整体一步执行(汇编级别)
thread step-inst、stepi、si
    单步运行,遇到子函数会进入子函数(汇编级别)
thread step-out、finish
    直接执行完当前函数所有代码, 返回到上一个函数(遇到断点会卡住)

补充知识点:

指令的内存地址 第几个字节           汇编指令
 0x10000d40    <+1>:    movq %rsp, %rbp
 
imm立即数, 也就是字面量

第五章 汇编分析结构体、类的内存布局

1-1、结构体

//在Swift标准库中, 绝大多数的公开类型都是结构体, 而枚举和类只占很小一部分
    //比如Bool、Int、Double、String、Array、Dictionary等常见类型都是结构体.
①struct Date {
②    var year: Int = 0
③  var month: Int
④  var day: Int
⑤}
⑥var date = Date(year: 2019, month: 6, day: 23)
//所有的结构体都有一个编译器自动生成的初始化器(Initializer, 初始化方法、构造器、构造方法)
//在第⑥行调用的, 可以传入所有成员值,用以初始化所有成员(存储属性, Stored Property)

1-2、结构体的初始化器

//编译器会根据情况, 可能会为结构体生成多个初始化器(比如给定成员初始值), 宗旨是: 保证所有成员都有初始值.
struct Point {
  var x: Int?
  var y: Int?
}
var p1 = Point(x:10, y:10)
var p2 = Point(y:10)
var p3 = Point(x:10)
var p4 = Point()
//可选项都有个默认值nil, 因此上面代码可以编译通过!!

1-3、自定义初始化器

//一旦在自定义结构体时定义了初始化器, 编译器就不会再帮它自动生成其他初始化器.
struct Point {
    var x: Int = 0
  var y: Int = 0
  init(x: Int, y: Int) {
    self.x = x
    self.y = y
  }
}
var p1 = Point(x: 10, y: 10)

1-4、窥探初始化器的本质

// 以下2端代码完全等效
struct Point {
    var x: Int = 0
  var y: Int = 0
}
var p = Point()

struct Point{
  var x: Int
  var y: Int
  init() {
    x = 0
    y = 0
  }
}
var p = Point()

2-1、类

//类的定义和结构体类似, 但编译器并没有为类自动生成可以传入成员值的初始化器
class Point {
  var x: Int = 0
  var y: Int = 0
}
let p1 = Point()
//如果类的所有成员都在定义的时候指定了初始值, 编译器会为类生成无参的初始化器
//成员的初始化是在这个初始化器中完成的

2-2、结构体与类的本质区别

//结构体是值类型(枚举也是值类型), 类是引用类型(指针类型)
class Size {
  var width = 1
  var height = 2
}
struct Point {
  var x = 3
  var y = 4
}
func test() {
  var size = Size()
  print("size变量的地址",Mems.ptr(ofVal: &size))
  print("size变量的内存",Mems.memStr(ofVal: &size))
  
  print("size所指向内存的地址",Mems.ptr(ofRef: size))
  print("size所指向内存的内容",Mems.memStr(ofRef: size))
  
  var point = Point() 
  print("point变量的地址",Mems.ptr(ofVal: &point))
  print("point变量的内存",Mems.memStr(ofVal: &point))
}
// 值类型的特点: 如果值类型是在函数里面创建的,那么它的内存肯定在栈空间里面
// 指针变量在64bit栈空间内存中占几个字节? 8个字节,存放的是Size对象的内存地址.Size对象在堆空间. Size对象在堆空间占用32个字节内存,分别是引用计数(8个字节)、指针类型信息(8个字节).
// 上面都是针对64bit环境
// 汇编中有alloc、malloc相关的信息, 说明系统分配在堆空间.

2-3、对象的堆空间申请过程

//在Swift中, 创建类的实例对象, 要向堆空间申请内存, 大概流程如下:
    Class._allocating_init()
    libswiftCore.dylib:_swift_allocObject_
    libswiftCore.dylib:swift_slowAlloc
    libsystem_malloc.dylib:malloc

//在Mac、iOS中malloc函数分配的内存大小总是16的倍数
var ptr = malloc(1) //申请1个字节的堆空间
print(malloc_size(ptr))// 16, 所指向的堆空间是16个字节
var ptr = malloc(17) //申请17个字节的堆空间
print(malloc_size(ptr))// 32, 分配给你的堆空间是32个字节

class Size {
  var width = 1
  var height = 2
}
var size = Size()
print(malloc_size(Mems.ptr(ofRef: size)))//size这个指针变量,它指向堆空间是32个字节

//通过class_getInstanceSize可以得知: 类的对象至少需要占用多少内存
class Point {
  var x = 11//8
  var text = true//1
  var y = 22//8
}//实际利用的字节为33个
var p = Point() // 要经过堆空间malloc检查, 是否为16的倍数
class_getInstanceSize(type(of:p))//40 内存对齐后,对象至少要占多少内存
class_getInstanceSize(Point.self)//40 对象占用多少内存,内存对齐是8
print(Mems.size(ofRef:p))//48 堆空间真实分配内存空间的大小,堆空间分配空间的时候,内存对齐是16

问:结构体都存在栈里?
答: 结构体内存在哪里取决于你在哪里定义的. 如果你的结构体变量是在函数里面定义的,那么它的内存肯定就在栈空间; 如果你的结构体变量在外部定义的,它的内存就在数据段,也就是全局区,因为它是个全局变量; 假如结构体是在对象里面,那么这个结构体肯定跟随对象在堆空间. 同理枚举.

2-4、值类型

值类型赋值给var、let或者给函数传参, 是直接将所有内容拷贝一份.
    类似于对文件进行copy、paste操作,产生了全新的文件副本.属于深拷贝(deep copy)
struct Point{
    var x: Int
  var y: Int
}
func test(){
  var p1 = Point(x: 10, y: 20)
  var p2 = p1
  p2.x = 11
  p2.y = 22
  //请问p1.x和p1.y是多少? 答: 10 20
}

/*规律: 
    内存地址格式为: 0x4bdc(%rip), 一般是全局变量, 全局区(数据段)
    内存地址格式为: -0x78(%rbp), 一般是局部变量, 栈空间
    内存地址格式为: 0x10(%rax), 一般是堆空间
*/

//值类型赋值操作
var s1 = "Jack"
var s2 = s1
s2.append("_Rose")
print(s1)// Jack
print(s2)// Jack_Rose

/* 
在Swift标注库中, 为了提升性能, String、Array、Dictionary、Set采用了Copy On Write的技术(也就是说当我们修改内存的时候,它才会进行深度拷贝操作,否则是浅拷贝).
        比如仅当有"写"操作时, 才会真正执行拷贝操作
        对于标准库值类型的赋值操作, Swift能确保最佳性能, 所以没必要为了保证最佳性能来避免赋值.
*/

2-5、引用类型

/*
引用赋值给var、let或者给函数传参, 是将内存地址拷贝一份.
        类似于制作一个文件的替身(快捷方式、链接),指向的是同一个文件.属于浅拷贝(shallow copy)
*/
class Size {
    var width: Int
    var height: Int
    init(width:Int, height:Int) {
      self.width = width
      self.height = height
    }
}
func test() {
    var s1 = Size(width: 10, height: 20)
    var s2 = s1
    s2.width = 11
    s2.height = 22
    //请问s1.width和s2.height是多少? 答:11 22
}

第六、七章 汇编分析闭包本质

1-1、嵌套类型

struct Poker {
  enum Suit : Character {
    case spades = "♠", hearts = "♥", diamonds="♦", clubs = "♣"
  }
  enum Rank : Int {
    case two = 2, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king, ace
  }
}

print(Poker.Suit.hearts.rawValue)

var suit = Poker.Suit.spades
suit = .diamonds

var rank = Poker.Rank.five
rank = .king

1-2、枚举、结构体、类都可以定义方法

一般把定义在枚举、结构体、类内部的函数, 叫做方法.
struct Point {
    var x = 10
  var y = 10
  func show(){//方法是不占用实例对象内存的, 方法的本质就是函数, 函数、方法都存放在代码段
    var a = 10//a局部变量
    print("局部变量(栈空间)",Mems.ptr(ofVal: &a))
    print("x=\(x),y=\(y)")
  }
}
let p = Point()//Point()在堆空间; p全局变量,在数据段的地方;
p.show() // x=10, y=10

print("全局变量",Mems.ptr(ofVal:&p))
print("堆空间",Mems.ptr(ofVal:p))

2-1、闭包表达式( Closure Expression)

/// 在Swift中, 可以通过func定义一个函数, 也可以通过闭包表达式定义一个函数
func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2}
// 简写一:
var fn = {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}
fn(10, 20)
// 简写二:
{
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}(10, 20)

/*闭包的格式写法:
{
  (参数列表) -> 返回值类型 in
  函数体代码
}
*/

2-2、闭包表达式的简写

func exec(v1: Int, v2: Int, fn:(Int, Int) -> Int) {
    print(fn(v1, v2))
}
// 简写一:
exec(v1: 10, v2: 20, fn:{
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
})
// 简写二: (省略参数类型)
exec(v1: 10, v2: 20, fn: {
    v1, v2 in return v1 + v2
})
// 简写三: 
exec(v1: 10, v2: 20, fn: {
    v1, v2 in v1 + v2
})
// 简写四:
exec(v1: 10, v2: 20, fn: {  $0 + $1 })
// 简写五:
exec(v1: 10, v2: 20, fn: + )

2-3、尾随闭包

/*如果将一个很长的闭包表达式作为函数的最后一个实参, 使用尾随闭包可以增加函数的可读性
    尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式
*/
func exec(v1: Int, v2: Int, fn:(Int, Int) -> Int) {
    print(fn(v1, v2))
}
//尾随闭包写法:
exec(v1: 10, v2: 20){
  $0 + $1
}

/*如果闭包表达式是函数的唯一实参, 而且使用了尾随闭包的语法, 那就不需要在函数名后边写圆括号
*/
func exec(fn:(Int, Int) -> Int) {
    print(fn(v1, v2))
}
exec(fn: { $0 + $1 })// 普通调用
exec() { $0 + $1 }// 尾随闭包写法
exec { $0 + $1 }// 尾随闭包简写

2-4、示例 - 数组的排序

func testSort(){
  var arr = [10, 1, 4, 20, 99]
  arr.sort()
  //arr.sort(by:(Int, Int) throws -> Bool)
  print(arr)
}

/*解析:
    func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
*/
/// 返回true: i1排在i2前面
/// 发挥false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
  // 大的排在前面
  return i1 > i2
}
var nums = [11, 2, 18, 6]
nums.sort(by: cmp)// [18, 11, 6, 2]
// 简写一:
nums.sort(by: {
    (i1: Int, i2: Int) -> Bool in
    return i1 < i2
})
// 简写二: 
nums.sort(by: {i1, i2 in return i1 < i2})
// 简写三: 
nums.sort(by: {i1, i2 in i1 < i2})
// 简写四: 
nums.sort(by: { $0 < $1 })
// 简写五: 
nums.sort(by: <)
// 简写六: 
nums.sort(){ $0 < $1 }
// 简写七: 
nums.sort { $0 < $1 }

3-1、闭包(Closure)

/*网上有各种关于闭包的定义, 个人觉得比较严谨的定义是:
        一个函数和它所捕获的变量/常量环境组合起来, 称为闭包
    一般指的是定义在函数内部的函数;
    一般它捕获的是外层函数的局部变量/常量.
*/
typealias Fn = (Int) -> Int //定义类型
/// 闭包写法一: (通过func)
func getFn() -> Fn{
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}// 返回的plus和num形成了闭包
/// 闭包写法二: (通过闭包表达式)
func getFn() -> Fn{
  var num = 0
  return {
    num += $0
    return num
  }
}
var fn1 = getFn()
var fn2 = getFn()
print(fn1(1)) // 1
print(fn2(2)) // 2
print(fn1(3)) // 4
print(fn2(4)) // 6

/*可以把闭包想象成一个类的实例对象
        内存在堆空间
        捕获的局部变量/常量就是对象的成员(存储属性)
        组成闭包的函数就是类内部定义的方法
*/
class Closure {
    var num = 0
  func plus(_ i: Int) -> Int {
    num += i
    return num
  }
}
var cs1 = Closure()
var cs2 = Closure()
cs1.plus(1)//1
cs2.plus(2)//2
cs1.plus(3)//4
cs2.plus(4)//6

3-2、练习

typealias Fn = (Int) -> (Int, Int)
func getFns() -> (Fn, Fn) {
  var num1 = 0
  var num2 = 0
  func plus (_ i: Int) -> (Int, Int) {
    num1 += i
    num2 += i << 1 // <<1 等于 *2
    return (num1, num2)
  }
  func minus(_ i: Int) -> (Int, Int) {
    num1 -= i
    num2 -= i << 1
    return (num1, num2)
  }
  return (plus, minus)
}
let (p, m) = getFns()
p(5) //(5,10)
m(4) //(1,2)
p(3) //(4,8)
m(2) //(2,4)

3-3、注意

//如果返回值是函数类型, 那么参数的修饰要保持统一
func add(_ num: Int) -> (inout Int) -> Void {
  func plus(v: inout Int) {//inout(输入输出参数), 与上面要保持统一
    v += num
  }
  return plus
}
var num = 5
add(20)(&num)
print(num)

3-4、自动闭包

// 如果第1个数大于0, 返回第一个数, 否则返回第2个数
func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
    return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 20) //10
getFirstPositive(-2, 20) //20
getFirstPositive(0, -4) //-4

// 改成函数类型的参数, 可以让v2延迟加载
func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4) { 20 }

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4, 20)
getFirstPositive(-4, {30})
// @autoclosure 会自动将20封装成闭包{ 20 }
// @autoclosure 只支持() -> T 格式的参数
// @autoclosure 并非只支持最后一个参数
// 空合并运算符 ?? 使用了 @autoclosure 技术
// 有@autoclosure、无@autoclosure, 构成了函数重载
// 为了避免与期望冲突, 使用了@autoclosure的地方最好明确注释清楚, 这个值会被推迟执行

第八章 属性、汇编分析inout本质

1-1、属性

/*Swift中跟实例相关的属性可以分为2大类
    存储属性( Stored Property)
            >类似于成员变量这个概念
            >存储在实例的内存中
            >结构体、类可以定义存储属性
            >枚举不可以定义存储属性
    计算属性( Computed Property)
            >本质就是方法(函数)
            >不占用实例的内存
            >枚举、结构体、类都可以定义计算属性
*/
struct Circle {
    //存储属性
    var radius: Double
    //计算属性
    var diameter: Double {
        set {
          radius = newValue / 2
        }
        get {
          radius * 2
        }
    }
}
var c = Circle(radius: 10)
c.radius = 11
c.diameter = 40
print(c.radius)// 20.0
print(MemoryLayout.stride)// 8

1-2、存储属性

/*关于存储属性, Swift有个明确的规定:
    在创建类或结构体的实例时, 必须为所有的存储属性设置一个合适的初始值
        >可以在初始化器里面为属性设置一个初始值
        >可以分配一个默认的属性值作为属性定义的一部分
*/

1-3、计算属性

/// set传入的新值默认叫做newValue, 也可以自定义
struct Circle {
    var radius: Double
  var diameter: Double {
    set(newDiameter){
      radius = newDiameter / 2
    }
    get {
      radius * 2
    }
  }
}

/// 只读计算属性: 只有get, 没有set
struct Circle {
    var radius: Double
  var diameter: Double {
    get {
      radius * 2
    }
  }
}
//简写:
struct Circle {
    var radius: Double
  var diameter: Double { radius * 2 }
}

/* 定义计算属性只能用var, 不能用let. 
            >let代表常量.值是一成不变的
            >计算属性的值是可能发生变化的(即使是只读计算属性)
*/

1-4、枚举rawValue原理

/*枚举原始值rawValue的本质是: 只读计算属性*/
enum TestEnum: Int {
    case test1 = 1, test2 = 2, test3 = 3
  var rawValue: Int {
    switch self {
      case .test1:
        return 10
      case .test2:
        return 11
      case .test3:
        return 12
    }
  }
}
print(TestEnum.test3.rawValue) //12

1-5、延迟存储属性( Lazy Stored Property)

/*使用lazy可以定义一个延迟存储属性, 在第一次用到属性的时候才会进行初始化*/
class Car {
  init(){
    print("car init!")
  }
  func run(){
    print("car is running!")
  }
}

class Person{
  lazy var car = Car()
  init(){
    print("Persion init!")
  }
  func goOut(){
    car.run()
  }
}
let p = Persion()
print("---------")
p.goOut()


class PhotoView {
  lazy var image: Image = {
    let url = "https://www.520it.com/xx.png"
    let data = Data(url: url)
    return Image(data: data)
  }()//闭包
}

/*
lazy属性必须是var, 不能是let
        let必须在实例的初始化方法完成之前就拥有值
如果多条线程同时第一次访问lazy属性
        无法保证属性只被初始化1次
*/
/*延迟存储属性注意点:
当结构体包含一个延迟属性时, 只有var才能访问延迟存储属性
        因为延迟属性初始化时需要改变结构体的内存
*/
struct Point {
    var x = 0
  var y = 0
  lazy var z = 0
}
let p = Point()//此时必须用var修饰
print(p.z)// 报错

1-6、属性观察器(Property Observer)

/*可以为非lazy的var存储属性设置属性观察器*/
struct Circle {
    var radius: Double {//存储属性
    willSet {
      print("willSet", newValue)
    }
    didSet {
      print("didSet", oldValue, radius)
    }
  }
  init(){
    self.radius = 1.0
    print("Circle init!")
  }
}
var circle = Circle() // Circle init
circle.radius = 10.5 //willSet 10.5  \n didSet 1.0 10.5
print(circle.radius)// 10.5
/*
  willSet会传递新增, 默认叫newValue
  didSet会传递旧值, 默认叫oldValue
  在初始化器中设置属性值不会触发willSet和didSet
        >在属性定义的时设置初始值也不会触发willSet和didSet
*/

1-7、全局变量、局部变量

/*属性观察器、计算属性的功能, 同样也可以应用在全局变量、局部变量身上*/
var num: Int {
    get {
    return 10
  }
  set {
    print("setNum",newValue)
  }
}
num = 11 // setNum 11
print(num)// 10


func test() {
  var age = 10 {
    willSet {
      print("willSet", newValue)
    }
    didSet {
      Print("didSet", oldValue, age)
    }
  }
  age = 11
  // willSet 11
  // didSet 10 11
}
test()

2-1、inout的再次研究

struct Shape {
    var width: Int
  var side: Int { //带有属性观察器的储存属性
    willSet {
      print("willSetSide", newValue)
    }
    didSet {
      print("didSetSide", oldValue, side)
    }
  }
  var girth: Int {
    set {
      width = newValue / side
      print("setGirth", newValue)
    }
    get {
      print("getGirth")
      return width * side
    }
  }
  func show(){
    print("width=\(width),side=\(side),girth=\(girth)")
  }
}

func test(_ num: inout Int) { //接收一个地址值,输入输出参数inout本质是引用传递
  print("test")
  num = 20
}

var s = Shape(width: 10, side: 4)
test(&s.width)
s.show()
print("-----------")
test(&s.side)
s.show()
print("-----------")
test(&s.girth)
s.show()
print("-----------")
/*inout的本质总结:
如果实参有物理内存地址, 且没有设置属性观察器
        直接将实参的内存地址传入函数(实参进行引用传递)
如果实参是计算属性 或者 设置了属性的观察者
        采用了Copy In Copy Out的做法:
                调用该函数时, 先复制实参的值, 产生副本[get]
                将副本的内存地址传入函数(副本进行引用传递),在函数内部可以修改副本的值
                函数返回后, 再将副本的值覆盖实参的值[set]
总结: inout的本质就是引用传递(地址传递)
*/

3-1、类型属性(Type Property)

/*严格来说, 属性可以分为:

    实例属性(Instance Property): 只能通过实例去访问
            >存储实例属性(Stored Instance Property): 存储在实例内存中, 每个实例都有1份
            >计算实例属性(Computed Instance Property)

    类型属性(Type Property):只能通过类型去访问
            >存储类型属性(Stored Type Property): 这个程序运行过程中, 就只有1份内存(类似于全局变量)
            >计算类型属性(Computed Type Property)

可以通过static定义类型属性
    如果是类, 可以通过关键字class. 不过关键字class不能修饰类中的存储属性
*/
class Shape {
    var width: Int = 0 //实例属性
        static var count: Int = 0 // static关键字声明类型属性
}
var s = Shape()
s.count = 10//报错
Shape.count = 10

struct Car {
  static var count: Int = 0
  init(){
    Car.count += 1
  }
}
let c1 = Car()
let c2 = Car()
let c3 = Car()
print(Car.count)//3

3-2、类型属性细节

/*不同存储实例属性, 你必须给存储类型属性设定初始值
        >因为类型没有像实例那样的init初始化器来初始化存储属性
存储类型属性默认就是lazy, 会在第一次使用的时候才初始化
        >就算被多个线程访问, 保证只会初始化一次
        >存储类型属性可以是let

枚举类型也可以定义类型属性(存储类型属性、计算类型属性)
*/
enum Shape {
    static var width: Int = 0 //可以定义类型属性, 不可以定义实例存储属性
  case s1, s2, s3, s4
}
var s = Shap.s1

/*单例模式*/
public class FileManager {
  public static let shared = FileManager()
  private init(){ 
   
  }
  func open() {
    
    }
    func close() {
      
    } 
}
FileManager.shared.open()
FileManager.shared.close()

第九章 汇编分析类型属性、方法、下标、继承

1-1、方法(Method)

/*枚举、结构体、类都可以定义实例方法、类型方法
        实例方法(Instance Method ) : 通过实例调用
        类型方法(Type Method): 通过类型调用, 用static或者class关键字定义
*/
class Car {
  static var count = 0
  init() {
    Car.count += 1
  }
  static func getCount() -> Int { count }
}
let c0 = Car()
let c1 = Car()
let c2 = Car()
print(Car.getCount()) //3
/*
self
        在实例方法中代表实例
        在类型方法中代表类型

在类型方法中 static func getCount中
        count等价于self.count、Car.self.count、Car.count
*/

1-2、mutating

/*结构体和枚举是值类型, 默认情况下, 值类型的属性不能被自身的实例方法修改
    在func关键字前面加mutating可以允许这种修改行为
*/
struct Point{
    var x = 0.0, y = 0.0
  mutating func moveBy(deltaX: Double, deltaY: Double) {
    x += deltaX
    y += deltaY
  }
}

enum StateSwitch {//状态开关
  case low, middle, high
  mutating func next() {
    switch self {
      case .low:
        self = .middle
      case .middle:
        self = .high
      case .high:
        self = .low
    }
  }
}

1-3、@discardableResult

// 在func前面加个@discardableResult, 可以消除: 函数调用返回值未被使用的警告⚠️
struct Point{
    var x = 0.0, y = 0.0
  @discardableRusult mutating func moveX(deltaX: Double) -> Double {
    x += deltaX
    return x
  }
}
var p = Point()
p.moveX(deltaX: 10)

@discardableResult func get() -> Int {
  return 10
}
get()

2-1、下标(subscribe)

/// 使用subscribe可以给任意类型(枚举、结构体、类)增加下标功能, 有些地方也翻译为: 下标脚本
// subscript的语法类似于实例方法、计算属性,本质就是方法(函数)
class Point{
  var x = 0.0, y = 0.0
  subscript(index: Int) -> Double {
    set {
      if index == 0 {
        x = newValue
      } else if index == 1{
        y = newValue
      }
    }
    get {
      if index == 0{
        return x
      } else if index == 1{
        return y
      }
      return 0
    }
  }
}

var p = Point()
p[0] = 11.1 //下标set方法
p[1] = 22.2
print(p.x)//11.1
print(p.y)//22.2
print(p[0])//11.1  下标get方法
print(p[1])//22.2

/*subscript中定义的返回值类型决定了:
    get方法的返回值类型
    set方法中newValue的类型

subscript可以接受多个参数,并且类型任意
*/

2-2、下标的细节

/// subscript可以没有set方法, 但必须要有get方法
class Point {
  var x = 0.0, y = 0.0
  subscript(index: Int) -> Double {
    get {
      if index == 0 {
        return x
      } else if index == 1 {
        return y
      }
      return 0
    }
  }
}
/// 如果只有get方法, 可以省略get
class Point {
    var x = 0.0, y = 0.0
  subscript(index: Int) -> Double {
    if index == 0{
      return x
    } else if index == 1{
      return y
    }
    return 0
  }
}

/// 可以设置参数标签
class Point {
  var x = 0.0, y = 0.0
  subscript(index i: Int) -> Double {
    if i == 0 {
      return x
    } else if i == 1{
      return y
    }
    return 0
  }
}
var p = Point()
p.y = 22.2
print(p[index: 1]) // 22.2

/// 下标可以是类型方法
class  Sum {
  static subscript(v1: Int, v2: Int) -> Int {
    return v1 + v2
  }
}
print(Sum[10, 20]) //30

2-3、结构体、类作为返回值对比

class Point {
  var x = 0, y = 0
}
class PointManager {
  var point = Point()
  subscript(index: Int) -> Point {
    get { point }//只有get方法, 给x/y赋值时会报错
  }
}


struct Point {//结构体是值类型, 下标不写set方法会报错
  var x = 0, y = 0
}
class PointManager {
  var point = Point()
  subscript(index: Int) -> Point{
    set { point = newValue } 
    get { point }
  }
}

var pm = PointManager()
pm[0].x = 11//本质: pm[0] = Point(x: 11, y: pm[0].y)
pm[0].y = 22//本质: pm[0] = Point(x: pm[0].x, y: 22)
// Point(x: 11, y:22)
print(pm[0])
//Point(x:11, y:22)
print(pm.point)


class Point {//类是引用类型, 下标不写set方法不会报错
  var x = 0, y = 0
}
class PointManager {
  var point = Point()
  subscript(index: Int) -> Point {
    get { point }//只有get方法, 给x/y赋值时不会报错
  }
}

2-4、接收多个参数的下标

class Grid {
  var data = [
    [0,1,2],
    [3,4,5],
    [6,7,8]
  ]
  subscript(row: Int, column: Int) -> Int {
    set {
      guard row >= 0 && row < 3 && column >= 0 && column < 3 else{
        return
      }
      data[row][column] = newValue
    }
    get {
      guard row >= 0 && row < 3 && column >=0 && column < 3 else{
        return 0
      } 
      return data[row][column]
    }
  }
}

var grid = Grid()
grid[0 ,1] = 77
grid[1, 2] = 88
grid[2, 0] = 99
print(grid.data)

3-1、继承(Inheritance)

/// 值类型(枚举、结构体)不支持继承, 只有类支持继承

/// 没有父类的类, 称为基类
    //swift并没有像OC、Java那样的规定: 任何类最终都要继承自某个基类

/// 子类可以重写父类的下标、方法、属性, 重写必须加上override关键字

3-2、内存结构

class Animal {
  var age = 0
}
class Dog : Animal {
  var weight = 0
}
class ErHa : Dog {
  var iq = 0
}

let a = Animal() //堆空间的对象, 堆空间的内存是16的倍数. 
a.age = 10
// 32
print(Mems.size(ofRef: a))
/*
0x00000001000073e0 //这8个字节存放类型信息
0x0000000000000002 //这8个字节存放引用计数相关信息
0x000000000000000a //这8个字节存储age
0x0000000000000000
*/
print(Mems.meStr(ofRef: a))

let d = Dog()
d.age = 10
d.weight = 20
// 32
print(Mems.size(ofRef: d))
/*
0x0000000100007490 //这8个字节存放类型信息
0x0000000000000002 //这8个字节存放引用计数相关信息
0x000000000000000a //这8个字节存储age
0x0000000000000014 //这8个字节存放weight
*/
print(Mems.memStr(ofRef: d))

3-3、重写实例方法、下标

class Animal {
  func speak() {
    print("Animal speak")
  }
  subscript(index: Int) -> Int {
    return index
  }
}

var anim: Animal
anim = Animal()
// Animal speak
anim.speak()
// 6
print(anim[6])

class Cat : Animal {
  override func speak(){
    super.speak()
    print("Cat speak")
  }
  override subscript(index: Int) -> Int {
    return super[index] + 1
  }
}

anim = Cat()
// Animal speak
// Cat speak
anim.speak()
// 7
print(anim[6])

3-4、重写类型方法、下标

/*
被class修饰的类型方法、下标, 允许被子类重写
被static修饰的类型方法、下标, 不允许被子类重写
*/
class Animal {
  class func speak(){
    print("Animal speak")
  }
  class subscript(index: Int) -> Int{
    return index
  }
}

class Cat : Animal {
  override func speak(){
    super.speak()
    print("Cat speak")
  }
  override subscript(index: Int) -> Int {
    return super[index] + 1
  }
}

3-5、重写属性

/* 
子类可以将父类的属性(存储、计算)重写为计算属性
子类不可以将父类属性重写为存储属性
只能重写var属性, 不能重写let属性
重写时, 属性名、类型要一致
子类重写后的属性权限, 不能小于父类属性的权限
    如果父类属性是只读的, 那么子类重写的属性可以是只读的、也可以是可读写的
    如果父类属性是可读写的, 那么子类重写后的属性也必须是可读写的
*/
class Aimal {
  var age = 0 //存储属性
}
class Dog : Animal {
  override var age = 0 //报错, 不允许
  var weight = 0
} 

/// 重写实例属性
class Circle {
  var radius: Int = 0.0 //直径 存储属性
  var diameter: Int { //半径 计算属性
    set {
      print("Circle setDiameter")
      radius = newValue / 2
    }
    get {
      pirnt("Cricle getDiameter")
      return = radius * 2
    }
  }
}

var circle: Circle
circle = Circle()
circle.radius = 6
// Circle getDiameter
// 12
print(circle.diameter)
// Circle setDiameter
circle.diameter = 20
// 10
print(circle.radius)

class SunCircle : Circle {
  override var radius: Int {//从父类继承过来的存储属性都是有存储空间的
    set {
      print("SubCircle setRadius")
      super.radius = newValue > 0 ? newVaule : 0
    }
    get {
      print("SubCricle getRadius")
      return super.radius
    }
  }
  override var diameter: Int {
    set {
      print("SubCircle setDiameter")
      super.diameter = newVlue > 0 ? newValue : 0
    }
    get {
      print("SubCircle getDiameter")
      return super.diameter
    }
  }
}

var circle = SubCircle()

// SubCircle setRadius
circle.radius = 6

// SubCircle getDiameter
// Circle getDiameter
// SubCircle getRaius
// 12
print(circle.diameter)

// SubCircle setDiameter
// Circle setDiameter
// SubCircle setRadius
circle.diameter = 20

// SubCircle getRadius
// 10
print(circle.radius)

3-6、重写类型属性

/*被class修饰的计算类型属性, 可以被子类重写; 存储属性不可以.
被static修饰的类型属性(计算、存储),不可以被子类重写
*/
class Circle {
  static var radius: Int = 0
  class var diameter: Int {
    set {
      print("Circle setDiameter")
      radius = newValue / 2
    }
    get {
        print("Circle getDiameter") 
      return radius * 2
    }
  }
}

class SubCircle : Circle {
  override static var diameter: Int {
    set {
      print("SubCircle setDiameter")
      super.diameter = newValue > 0 ? newValue : 0
    }
    get {
      print("SubCircle getDiameter")
      return super.diameter
    }
  }
}

3-7、属性观察器

/// 可以在子类中为父类属性(除了只读计算属性、let属性)增加属性观察器
class Circle {
  var radius: Int = 1
}
class SubCircle: Circle {
  override var radius: Int {//此处不是重写计算属性, 只是添加属性观察器
    willSet {
      print("SubCircle willSetRadius", newValue)
    }
    didSet {
      print("SubCircle didSetRadius", oldValue, radius)//访问radius的存储属性
    }
  }
}
var circle = SubCircle()
// SubCircle willSetRadius 10
// SubCircle didSetRadius 1 10
circle.radius = 10


class Circle {
  var radius: Int = 1 {//存储属性
    willSet {
      print("Circle willSetRadius", newValue)
    }
    didSet {
      print("Circle didSetRadius", oldValue, radius)
    }
  }
}
class SubCircle: Circle {
  override var radius: Int {
    willSet {
      print("SubCircle willSetRadius", newValue)
    }
    didSet {
      print("SubCircle didSetRadius", oldValue, radius)
    }
  }
}
var circle = SubCircle()
// SubCricle willSetRadius 10
// Circle willSetRadius 10
// Circle didSetRadius 1 10
// SubCricle didSetRadius 1 10
circle.radius = 10


class Circle {
  var radius: Int {// 实例计算属性
    set {
      print("Circle setRadius", newValue)
    }
    get {
      print("Circle getRadius")
      return 20
    }
  }
}
class SubCircle: Circle {
  override var radius: Int {
    willSet {
      print("SubCircle willSetRadius", newValue)
    }
    didSet {
      print("SubCircle didSetRadius", oldValue, radius)
    }
  }
}


class Circle {
  class var radius: Int {// 类型计算属性
    set {
      print("Circle setRadius", newValue)
    }
    get {
      print("Circle getRadius")
      return 20
    }
  }
}
class SubCircle: Circle {
  override static var radius: Int {
    willSet {
      print("SubCircle willSetRadius", newValue)
    }
    didSet {
      print("SubCircle didSetRadius", oldValue, radius)
    }
  }
}
// Circle getRadius
// SubCircle willSetRadius 10
// Circle setRadius 10
// Circle getRadius
// SubCircle didSetRadius 20 20
SubCircle.radius = 10

第十章 汇编分析多态原理、初始化、可选链

1-1、多态的实现原理

/*多态的实现原理: 
1. OC: Runtime
2. C++: 虚表(虚函数表)

Swift中没有runtime, Swift的实现跟虚表有点像, Swift中多态的实现原理
父类指针指向子类对象
*/
class Animal {
  func speak() {
    print("Animal speak")
  }
  func eat() {
    print("Animal eat")
  }
  func sleep() {
    print("Animal sleep")
  }
}
class Dog : Animal {
  func speak() {
    print("Dog speak")
  }
  func eat() {
    print("Dog eat")
  }
  func run() {
    print("Dog run")
  }
}

var anim: Animal
anim = Animal()
animal.speak()
animal.eat()
animal.sleep()

anim = Dog()//父类指针指向子类对象
anim.speak()
anim.eat()
anim.sleep()
//anim.run()

1-2、多态的实现原理

/*Swift中多态的使用原理:
类似于C++的虚表,直接将这个对象将来要调用的函数内存地址,提前放到类型信息那里, 这些类型信息肯定是编译完就可以确定的调用谁,程序运行过程中就去那块内存中找就可以了
*/

2-1、初始化

/*
类、结构体、枚举都可以定义初始化器.
类有2种初始化器: 指定初始化器(designated Initializer)、便捷初始化器(convenience Initializer).

每个类至少有一个指定初始化器, 指定初始化器是类的主要初始化器.
默认初始化器总是类的指定初始化器.
类偏向于少量指定初始化器, 一个类通常只有一个指定初始化器.

初始化器的相互调用规则:
    指定初始化器必须从它的直系父类调用指定初始化器;
    便捷初始化器必须从相同的类里调用另一个初始化器;
    便捷初始化器最终必须调用一个指定初始化器.
*/

/// 指定初始化器
init(parameters) {
    statements
}

/// 便捷初始化器
convenience init(parameters) {
    statements
}

class Size {
  // init(){ } 默认初始化器
  var width: Int = 0
  var height: Int = 0
  init(width: Int, height: Int){// 指定初始化器(主要初始化器)
    self.width = width
    self.height = height
  }
  convenience init(width: Int, height: Int){// 便捷初始化器
    self.init()
    self.width = width
    self.height = height
  }
}
var s = Size(width: 10, height: 20)//调用初始化器

2-2、便捷初始化器最终必须调用一个指定初始化器

class Size {
  var width: Int
  var height: Int
  init(width: Int, height: Int) {// 指定初始化器(主要初始化器)
    self.width = width
    self.height = height
  }
  convenience init(width: Int) {
    self.init(width: width, height: 0)
  }
  convenience init(height: Int) {
    self.init(width: 0, height: height)
  }
  convenience init() {
    self.init(width: 0, height: 0)
  }
}
var s1 = Size(width: 10, height: 20)
var s2 = Size(width: 10)
var s3 = Size(height: 10)
var s4 = Size()

2-3、指定初始化器必须从它的直系父类调用指定初始化器

class Person {
  var age: Int
  init(age: Int) {
    self.age = age
  }
  convenience init() {
    self.init(age: 0)
  }
}
class Student : Person {
  var score: Int
  init(age: Int, score: Int) {//自己的指定初始化器, 必须指定父类的指定初始化器
    // 第一阶段: 初始化所有存储属性
    self.score = score//必须放在调用父类指定初始化器之前
    super.init(age: age)
    // 第二阶段:实例个性化定制
    self.age = age
  }
  convenience init() {//自己的便捷初始化器, 必须指定自己的指定初始化器
    self.init(age: 0, score: 0)
  }
  convenience init(score: Int) {//自己的便捷初始化器, 必须指定自己的指定初始化器
    self.init(age: 0, score: score)
  }
}

2-4、两段式初始化

/*
Swift在编码安全方面是煞费苦心, 为了保证初始化过程的安全, 设定了两段式初始化、安全检查

两段式初始化:
    第1阶段: 初始化所有存储属性
        ① 外层调用指定/便捷初始化器
        ② 分配内存给实例, 但未初始化
        ③ 指定初始化器确保当前类定义的存储属性都初始化
        ④ 指定初始化器调用父类的初始化器, 不断向上调用, 形成初始化器链

    第2阶段: 设置新的存储属性值
        ① 从顶部初始化器往下, 链中的每一个指定初始化器都有机会进一步定制实例
        ② 初始化器现在能够使用self(访问、修改它属性, 调用它的实例方法等等)
        ③ 最终,链中任何便捷初始化器都有机会定制实例以及使用self

安全检查: 
    指定初始化器必须保证在调用父类初始化器之前, 其所在类定义的所有存储属性都要初始化完成;
    指定初始化器必须调用父类初始化器, 然后才能成为继承的属性设置新值;
    便捷初始化器必须先调用同类中的其它初始化器, 然后再为任意属性设置新值;
    初始化器在第1阶段初始化完成之前, 不能调用任何实例方法、不能读取任何实例属性的值,也不能引用self;
    直到第1阶段结束, 实例才算完全合法.
*/

2-5、重写父类的指定初始化器

/// 当重写父类的指定初始化器时,必须加上override(即使子类的实现是便捷初始化器)
class Person {
  var age: Int
  init(age: Int) {
    self.age = age
  }
}
class Student : Person {
  var score: Int
  init(age: Int, score: Int) {
    self.score = score
    super.init(age: age)
    self.age = age
  }
 // override init(age: Int) { //重写为指定初始化器
 //   self.score = 0 //把自己的初始化完成,再调用父类指定初始化器
 //   self.init(age: age)
 // }
  override convenience init(age: Int) {//重写为便捷初始化器
    self.init(age: age, score:0)//调用自己的指定初始化器
    score = 15
  }
}

/// 如果子类写了一个匹配父类便捷初始化器的初始化器, 不用加上override
    // 因为父类的便捷初始化器永远不会通过子类直接调用, 因此, 严格来说, 子类无法重写父类的便捷初始化器
class Person {
  var age: Int
  init(age: Int) {
    self.age = age
  }
  convenience init() {
    self.init(age: 0)
  }
}
class Student : Person {
  var score: Int
  init(age: Int, score: Int) {
    self.score = score
    super.init(age: age)
    self.age = age
  }
    init() {//此处不算重写, 不用加override
    self.score = 0
    super.init(age: 0)
  }
  convenience init() {
    self.init(age: 0, score: 0)
  }
}

2-5、自动继承

/*
① 如果子类没有自定义任何指定初始化器, 它会自动继承父类所有的指定初始化器

② 如果子类提供了父类所有指定初始化器的实现(要么通过方式①继承,要么重写)
        子类自动继承所有的父类便捷初始化器

③ 就算子类添加了更多的便捷初始化器, 这些规则仍然适用

④ 子类以便捷初始化器的形式重写父类的指定初始化器, 也可以作为满足规则②的一部分
*/

class Person {
  var age: Int
  var name: String
  init(age: Int, name: String) {
    self.age = age
    self.name = name
  }
  init() {
    self.age = 0
    self.name = 0
  }
  convenience init(age: Int) {
    self.init(age: age, name: "")
  }
  convenience init(name: String) {
    self.init(age: 0, name: name)
  }
}

class Student : Person {
  var no: Int = 0
  convenience init(no: Int) {
    self.init()
  }
}
// 只要我们自定义了指定初始化器, 那么父类的指定初始化器就不能继承下来.

第十一章 init、deinit、可选链、协议、元类型

1-1、required

/*
        用required修饰指定初始化器, 表明其所有子类都必须实现该初始化器(通过继承或重写实现)
        如果子类重写required初始化器时也必须加上required, 不用加override
*/
class Preson {
  required init() { }
  init(age: Int)
}
class Student: Preson {
  required init() {
    super.init()
  }
}

1-2、属性观察器

/*
    父类的属性在它自己的初始化器中赋值不会触发属性观察器,但在子类的初始化器中赋值会触发属性观察器
*/
class Preson {
  var age: Int {
    willSet {
      print("willSet", newValue)
    }
    didSet {
      print("didSet", oldValue, age)
    }
  }
  init() {
    self.age = 0
  }
}

class Student: Person {
  override init() {
    super.init()
    self.age = 1
  }
}

// willSet 1
// didSet 0 1
var stu = Student()

1-3、可失败初始化器

// 类、结构体、枚举都可以使用init?定义可失败初始化器
class Person {
    var name: String
  init?(name: String){
    if name.isEmpty {
      return nil
    }
    self.name = name
  }
}

//之前接触过的可失败初始化器
var num = Int("123")
public init?(_description: String)// Int类型初始化源码

enum Answer : Int {
    vase wrong, right
}
var an = Answer(rawValue: 1) //枚举的初始化器

/*
    不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器
    可以用init!定义隐式解包的可失败初始化器
    可失败初始化器可调用非可失败初始化器, 非可失败初始化器调用可失败初始化器需要进行解包
    如果初始化器调用一个可失败初始化器导致初始化失败, 那么整个初始化过程都失败, 并且之后的代码都停止执行
    可以用一个非可失败的初始化器重写一个可失败初始化器, 但反过来是不行的
*/
class Person {
    var name: String
  /*
  init!(name: String){//定义隐式解包的可失败初始化器
    if name.isEmpty {
      return nil
    }
    self.name = name
  }
  convenience init() {
    self.init(name: "")
  }
  */
  /*
  init?(name: String){
    if name.isEmpty {
      return nil
    }
    self.name = name
  }
  convenience init() {
    self.init(name: "")!//需强制解包
  }
  */
  init?(name: String){
    if name.isEmpty {
      return nil
    }
    self.name = name
  }
  convenience init?() {
    self.init(name: "")
    self.name = "Jack"
    // ....
  }
}
class Student : Person {
  override init(name: String){
    // ....
  }
}

var p1 = Person(name: "")
print(p1)
var p2 = Person(name: "Jack")
print(p2)

2-1、反初始化器(deinit)

/*
deinit叫做反初始化器, 类似于C++的析构函数、OC中的dealloc方法
    当类的实例对象被释放内存时,就会调用实例对象的deinit方法
*/
class Person {
  deinit {
    print("Preson对象销毁了")
  }
}
class Student : Person {
    deinit {
    print("Student对象销毁了")
  }
}
var stu: Student? = Student() //ARC
stu = nil
/*deinit不接受任何参数, 不能写小括号, 不能自行调用
    父类的deinit能被子类继承
    子类的deinit实现执行完毕后会调用父类的deinit
*/

3-1、可选链 ( Optional Chaining )

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()
var age1 = person!.age() // Int
var age2 = person?.age() // Int?
var name = person?.name // String?
var index = person?[6] //Int?

func getName() -> String { "jack" }
// 如果person是nil, 不会调用getName()
person?.name = getName()

/*
如果可选项为nil, 调用方法、下标、属性失败, 结果为nil
如果可选项不为nil, 调用方法、下标、属性成功, 结果会被包装成可选项
    如果结果本来就是可选项, 不会进行再包装
*/
if let _ = person?.eat() {// ()?
  print("eat调用成功")
} else {
    print("eat调用失败")
}

var dog = person?.dog //Dog?
var weigth =  person?.dog.weight // Int?
var price = person?.car?.price //Int?
/*多个? 可以链接在一起
    如果链中任何一个节点是nil, 那么整个链就会调用失败
*/

3-2、可选链

var scores = ["Jack": [86, 82, 84], "Rose": [79, 94, 81]]
scorces["Jack"]?[0] = 100
scorces["Rose"]?[2] += 10
scorces["Kate"]?[0] = 88

var num1: Int? = 5
num1? = 10 // Optional(10)

var num2: Int? = nil
num2? = 10 // nil

var dict: [String : (Int, Int) -> Int] = [//字符串作为key,函数作为value
  "sum" : (+), // (+)这是语法糖,表示两个Int相加,返回Int类型
  "difference" : (-)// (-)这是语法糖,表示两个Int相减,返回Int类型
]
var result = dict["sum"]?(10, 20) // Optional(30), Int?

4-1、协议 ( Protocol )

/*协议可以用来定义方法、属性、下标的声明, 协议可以被枚举、结构体、类遵守(多个协议之间用逗号隔开)*/
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 { }

/*
    协议中定义方法时不能有默认参数值
    默认情况下, 协议中定义的内容必须全部实现
        也有办法办到只实现部分内容, 后面会谈到
*/

4-2、协议中的属性

/*
    协议中定义属性必须用var关键字
    实现协议的属性权限要不小于协议中定义的属性权限
        协议定义get、set, 用var存储属性或get、set计算属性去实现
        协议定义get, 用任何属性都可以实现
*/
protocol Drawable {
  func draw()
  var x: Int { get set }
  var y: Int { get }
  subscript(index: Int) -> Int { get set }
}

class Person : Drawable{
  var x: Int = 0 // 通过存储属性实现协议
  let y: Int = 0
  func draw() {
    print("Person draw")
  }
  subscript(index: Int) -> Int {
    set { }
    get { index }
  }
}

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

4-3、static、class

/*为了保证通用, 协议中必须用static定义类型方法、类型属性、类型下标*/
protocol Drawable {
  static func draw()
}

class Person1: Drawable {
  class func draw() {
    print("Person1 draw")
  }
}

class Person2: Drawable {
  static func draw() {
    print("Person2 draw")
  }
}

4-4、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 func draw() {
    x = 10
  }
}

4-5、init

/*协议中还可以定义初始化器init
    非final类实现时必须加上required
*/
protocol Drawable {
    init(x: Int, y: Int) //定义初始化器
}

class Point : Drawable {// 非final类. 将来可能有子类
  required init(x: Int, y: Int) { } //遵守协议实现方法, required表示它的所有子类都必须遵守这个协议
}

final class Size : Drawable {// final类, 规定将来没有子类
    init(x: Int, y: Int) { }
}

/*如果从协议实现的初始化器, 刚好是重写了父类的指定初始化器
    那么这个初始化必须同时加required、override
*/
protocol Livable {
    init(age: Int)
}

class Person {
  init (age: Int) { }
}

class Student : Person, Livable {
  required override init(age: Int) {
    super.init(age: age)
  }
} 

4-6、required

/*
    用required修饰指定初始化器, 表明其所有子类都必须实现该初始化器(通过继承或重写实现)
    如果子类重写了required初始化器, 也必须加上required, 不用加override
*/
class Person {
  required init() { }
  init (age: Int) { }
}

class Student : Person {
  required init() {
    super.init()
  }
} 

4-7、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() { }
  // reuqired 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) { }
}

4-8、协议的继承

/*一个协议可以继承其他协议*/
protocol Runnable {
    func run()
}

protocol Livable : Runnable {
  func breath()
}

class Person : Livable {
  func breath() { }
  func run() { }
}

4-9、协议组合

/*协议组合, 可以包含1个类类型(最多1个), 枚举和结构体则不能存在其中*/
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) { }

4-10、CaseIterable

/*让枚举遵守CaseIterable协议, 可以实现遍历枚举值*/
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

4-11、CustomStringConvertible

/*遵守CustomStringConvertible协议, 可以自定义实例的打印字符串*/
class Person : CustomStringConvertible {
  var age: Int
  var name: String
  init(age: Int, name: String){
    self.age = age
    self.name = name
  }
  var description: String { //只读的计算属性
    "age=\(age), name=\(name)"
  }
}
var p = Person(age: 10, name: "Jack")
print(p) //age = 10, name=Jack

5-1、Any、AnyObject

/*Swift提供了2种特殊的类型: Any、AnyObject
    Any : 可以代表任意类型 (枚举、结构体、类、也包括函数类型)
    AnyObject: 可以代表任意类类型 (在协议后面写上: AnyObject代表只有类能遵守这个协议)
*/
protocol Runnable: AnyObject { }//AnyObject代表类类型的实例, 这样写代表只有类才能遵守这个协议
class Person : Runnable { }
struct Size : Runnable { }// 报错

var stu: Any = 10
stu = "Jack"
stu = Student()

//创建1个能存放任意类型的数组
// var data = Array()
var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Student())
data.append("Jack")
data.append({ 10 })

6-1、is、as?、as!、as

/*is用来判断是否为某种类型, 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
stu = "Jack"
print(stu is String) //true
stu = Student()
print(stu is Person) //true
print(stu is Student) //true
print(stu is Runnable) //true

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)
print(data.count)

var d = 10 as Double
print(d) // 10.0

7-1、 X.self、 X.Type、AnyClass

/*
    X.self是一个元类型(metadata)指针, metadata存放着类型相关信息;
    X.self属性X.Type类型;
*/
class Person{
  
}
var p:Person = Person()
var pType: Person.Type = Person.self // 元类型指针(取出Person堆空间的前8个字节出来, 指向Person元类型的地址值)

var anyType: AnyObject.Type = Person.self
anyType = Student.self

public typealias AnyClass = AnyObject.Type
var anyType2: AnyClass = Person.self
anyType2 = Student.self

var per = Person()
//type(of: x) 接收一个实例,能告诉你这个实例的类型是什么
var perType = type(of: per) // Person.self
print(Person.self == type(of: per)) // true

7-2、元类型的应用

class Animal { required init() { } }// 必须使用 required 修饰,确保子类一定有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()) //cls.init()调用初始化方法,返回实例
  }
  return arr
}
print(create([Cat.self, Dog.self, Pig.self]))

/*比如:
TabBarContorller 
1: HomeVIewController
2: AboutViewController

// oc
NSArray *array = @[HomeViewController.class, AboutViewController.class];
for(cls in array){
    [[cls alloc]init];
}
//swift
var array = @[HomeViewController.self, AboutViewController.self];
....
*/

import Foundation 
class Person {
    var age: Int = 0
}
class Student : Person {
    var no: Int = 0
}
//runtime: class_getInstanceSize获取类创建出实例对象需要多少内存
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
*/
/*有些runtime的函数还是可以用在纯Swift中*/

7-3、Self

/*Self一般用作返回值类型, 限定返回值跟方法调用者必须是同一类型(也可以作为参数类型)*/
protocol Runnable {
  func test () -> Self
}
class Person : Runnable {
  required init() { }//如果Self用在类中, 要求返回时调用的初始化器是required的
  func test() -> Self { type(of: self).init() }
}
class Student : Person { }

var p = Person()
print(p.test())// Test.Person

var stu = Student()
print(stu.test())// Test.Student

7-4、Person和Person.self

class Person {
  static var age = 0 //类型属性类型方法, 用类去调用
  static func run() {}
}
Person.age = 10 //Person代表一个类名
Person.run()

Person.self.age = 10//等同于上面
Person.self.run()// Person.self代表元类型指针

/// 下面的实例方法效果都是一样的
var p0 = Person()//init()
var p01 = type(of: p0).init()
var p1 = Person.self()//init()
var p2 = Person.init()//init()
var p3 = Person.self.init()//init()

// var pType0 = Person
var pType1 = Person.self

/*AnyClass相当于AnyObject.Type*/
func test(_ cls: AnyClass) {
  
}
test(Person.self)

/*总结:
共同点: 都能去访问类型属性和类型方法
区别: 一个叫元类类型, 类型不同
*/