简介

Swift是Apple在2014年6月 WWDC 发布的全新编程语言，中文名和LOGO是“雨燕”, Swift之父Chris Lattner;

历时5年发展，从Swift1.x发展到了Swift5.x版本，经历了多次重大改变，ABI(应用程序二进制接口)基于稳定

image.png

Hello, world

print("Hello, world!")

在 Swift 语言当中，这一行代码就是一个完整的程序！

1. 不用编写main函数，Swift将全局范围内的首句可执行代码作为程序入口
2. 一句代码尾部可以省略分号(;)，多句代码写到同一行时必须用分号(;)隔开

指南

Swift 基础语法

1.简单值

使用 let来声明一个常量，用 var来声明一个变量, 它的值不要求在编译时期确定，但使用之前必须赋值1次

// 常量声明并初始化
let str = "hello,world!"

// 声明变量,未初始化
var num:Int;
num = 10;

如果直接初始化可以不用显示的写类型,如果仅声明未初始化就需要添加类型

2. 类型标注

在声明一个变量或常量的时候提供类型标注，来明确变量或常量能够储存值的类型;

var num: Int = 100

3. 数据类型

image.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位

字面量

// 布尔值
let bool = true
// 字符串
let str1 = "hello,world"
// 字符
let characher:Character = ""
// 整数
let intDeciaml = 17 // 十进制
let intBinary = 0b10001 // 二进制
let intOctal = 0o21   //八进制
let intHexadecimal = 0x11 //十六进制
// 浮点型
let doubleDecimal = 125.0 // 十进制 125.0等价于 1.25e2    1.25e2 (e2)表示10的二次方. 1.25*10^2
// 数组
let array = [1,2,3,4,5,6,7,8,9.10]
// 字典
let dict = ["age":18, "height":100, "width":200]

5. 元组

// 定义元组,通过.0 或 .1来访问内部属性
let http404Error = (404,"网页不存在")
print(http404Error.0, http404Error.1)

// 定义元组,分别给元组内参数赋值,通过参数进行访问
let (statusCode, errorString) = (404,"网页不存在")
print(statusCode, errorString)

// 使用_,表示不赋值
let (statusCode1, _) = (404,"网页不存在")
print(statusCode1)

// 通过元组内部参数进行访问
let http200Status = (statusCode:200, statusString:"请求成功")
print(http200Status.statusCode, http200Status.statusString)

Swift 流程控制

1. if-else

• if 后面的条件只能是Bool类型, if 后面括号可以省略

var age : Int = 30
if age == 30 {
    print("my age is \(age)")
}

2. while

• while 后面需要时 bool 类型
• repeat-while 等同于 do-while

var count = 0
while count<=5 {
    print("num is \(count)")
    count += 1
}

count = 0
repeat {
    print("num is \(count)")
}while count>0

3. for-in

区间运算

• 闭区间运算符:a...b ,表示 a<= 取值 <=b
• 半开区间运算符:a..<b， a <= 取值 < b
• 单侧区间:让区间朝一个方向尽可能的远 a..., a 到无限大

// 区间类型
let rang1: ClosedRange<Int> = 1...3
let rang2: Range<Int> = 1..<3
let rang3: PartialRangeThrough<Int> = ...3

for-in常见写法

// 方式一: 默认num是let 类型,可以省略不写
for num in 1...10{
    print(num)
}
// 方式二: 如果要修改 num 的值,需要更改为变量
for var num in 1...10 {
    num += 100
    print(num)
}
// 方式三: 去过不需要用到 num 可以使用_缺省
for _ in 1...10 {
    print("hello,world")
}

• 区间运算符应用

// 设置数组的取值范围
let arr2 = ["my", "name", "is", "Alex"]
for str in arr2[1...2] {
    print(str)
}
// 单侧区间运算符
for str in arr2[2...] {
    print(str)
}

• 带间隔的区间值, 使用 stride来进行间隔设置

// num 的取值:从50开始，累加10，不超过100
let number = 10
for num in stride(from: 50, to: 100, by: number) {
    print(num)
}

4. Switch

switch 与普通 switch 使用类似

注意点:

• case、default后面不能写大括号{}
• 使用fallthrough可以实现贯穿效果
• switch必须要保证能处理所有情况
• case、default后面至少要有一条语句 ;如果不想做任何事，加个break即可
• 如果能保证已处理所有情况，也可以不必使用default
• switch也支持Character、String类型

enum Answer { case right, wrong }
let answer = Answer.right
switch answer {
case .right:
    print("right")
case .wrong:
    print("wrong")
}

• 复合条件

let name = "chuan"
switch name {
// 使用, 分割,可以同时判断多个条件,满足一个即执行
case "chuan", "bing":
    print("chuan/bing")
default:
    break
}

• 区间匹配、元组匹配

// 区间匹配
let count_num = 99
switch count_num {
case 1...10:
    print("1...10")
case 11...20:
    print("11...20")
case 21..<30:
    print("21..<30")
case 30...:
    print(count_num)
default:
    break
}

// 元组匹配
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")
}

• 值绑定,如果有一个值相同,另外一个则会进行绑定

// 值绑定
let point1 = (1, 1)
switch point1 {
case (let x, 0):
    print("the origin is\(x)")
case (let x, let y):
    print("x is \(x), y is \(y)")
case let (x, y):
    print("xxxx is \(x), yyyy is \(y)")
default:
    print("outside of the box")
}

5. where

where用于判断某个条件满足才会进行执行

// for
for num in 1...100 where num % 10 == 0 {
    print(num)
}

// switch
let point2 = (1, 2)
switch point2 {
case let (x, y) where x == y:
    print("x is \(x) y is \(y)")
case let (x, y) where x != y:
    print("xx is \(x) yy is \(y)")
default:
    break
}

Swift 函数

1. 定义和调用函数

• func的为函数关键字前缀, ->表示 函数返回的类型

func greet(person: String) -> String{
    let greeting = "hello" + person + "!"
    return greeting
}
greet(person: "Alex")

2. 隐式返回

• 如果整个函数体是一个单一表达式，那么函数会隐式返回这个表达式

 func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
sum(v1: 10, v2: 20) 

3. 返回元组:实现多返回值

func calculate(v1 : Int, v2: Int) -> (sum: Int, subtract: Int, average: Int){
    let sum = v1 + v2;
    let subtract = v1 - v2;
    let average = sum / 2
    return (sum, subtract, average)
}
calculate(v1: 20, v2: 10)

4. 参数标签

• 可以修改参数标签,方便阅读

func gotowork(at time: String){
    print("this time is \(time)")
}
gotowork(at: "08:00")

• 可以使用下划线_ 省略参数标签

func sum(_ v1: Int, _ v2: Int) -> Int {
    return v1 + v2;
}
let result =  sum(10, 20)

5. 默认参数值

• 参数可以有默认值

func check(name: String = "nobody", age: Int, job: String = "none") {
    print("name=\(name), age=\(age), job=\(job)")
}
// 2种调用方式
check(age: 10)
check(name: "alex", age: 30, job: "it")

6. 可变参数

• 一个参数可以传入多个值

 func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
}
    return total
}
sum(10, 20, 30, 40) // 100

• 一个函数最多只能有1个可变参数,紧跟在可变参数后面的参数不能省略参数标签

 // 参数string不能省略标签
func test(_ numbers: Int..., string: String, _ other: String) { }
test(10, 20, 30, string: "Jack", "Rose")
 

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

可以用inout定义一个输入输出参数:可以在函数内部修改外部实参的值

• 可变参数不能标记为inout
• inout参数不能有默认值
• inout参数的本质是地址传递(引用传递) n inout参数只能传入可以被多次赋值的

func swapValues(v1: inout Int, v2: inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(v1: &num1, v2: &num2)

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: Int, v2: Double) -> Double { 
    Double(v1) + v2
} // 参数类型不同
 func sum(_ v1: Int, _ v2: Int) -> Int { 
    v1 + v2
} // 参数标签不同

9. 内联函数(Inline Function)

如果开启了编译器优化(Release模式默认会开启优化)，编译器会自动将某些函数变成内联函数

• 将函数调用展开成函数体

哪些函数不会被内联?

• 函数体比较长
• 包含递归调用
• 包含动态派发

image.png

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

11. typealias

• typealias用来给类型起别名

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

typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date) {
    print(date.0)
    print(date.year)
}
test((2011, 9, 10))

typealias IntFn = (Int, Int) -> Int

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就是空元组()

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

Swift 闭包

在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数

1 闭包表达式

• 闭包表达式

{
    (参数列表) -> 返回值类型 in 函数体代码
}

• 闭包表达式的简写

// 定义函数,并引入闭包表达式
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
})
// 从单表达式闭包隐式返回,删掉 return 关键字来隐式返回它们单个表达式的结果
exec(v1: 10, v2: 20, fn: {
    v1, v2 in v1 + v2
})
// 简写的实际参数名,动对行内闭包提供简写实际参数名，你也可以通过 $0 , $1 , $2 等名字来引用闭包的实际参数值。
exec(v1: 10, v2: 20, fn: { $0 + $1 })
// 运算符函数
exec(v1: 10, v2: 20, fn: +)

2 尾随闭包

如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性

• 尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式

 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(1, 2))
}

exec(fn: { $0 + $1 })
exec() { $0 + $1 }
exec { $0 + $1 }

3. 逃逸闭包

当闭包作为一个实际参数传递给一个函数的时候，我们就说这个闭包逃逸了，可以在形式参数前写 @escaping 来明确闭包是允许逃逸的。

闭包可以逃逸的一种方法是被储存在定义于函数外的变量里。比如说，很多函数接收闭包实际参数来作为启动异步任务的回调。函数在启动任务后返回，但是闭包要直到任务完成——闭包需要逃逸，以便于稍后调用。

// 定义一个数组用于存储闭包类型
var completionHandlers: [() -> Void] = []

//  在方法中将闭包当做实际参数,存储到外部变量中
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

如果你不标记函数的形式参数为 @escaping ，你就会遇到编译时错误。

4. 自动闭包

自动闭包是一种自动创建的用来把作为实际参数传递给函数的表达式打包的闭包。它不接受任何实际参数，并且当它被调用时，它会返回内部打包的表达式的值。这个语法的好处在于通过写普通表达式代替显式闭包而使你省略包围函数形式参数的括号。

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive(10, 20)

• 为了避免与期望冲突，使用了@autoclosure的地方最好明确注释清楚:这个值会被推迟执行
• @autoclosure 会自动将 20 封装成闭包 { 20 }
• @autoclosure 只支持 () -> T 格式的参数
• @autoclosure 并非只支持最后1个参数
• 有@autoclosure、无@autoclosure，构成了函数重载
• 如果你想要自动闭包允许逃逸，就同时使用 @autoclosure 和 @escaping 标志。

Swfit 枚举

枚举为一组相关值定义了一个通用类型，从而可以让你在代码中类型安全地操作这些值。

1. 枚举的基本用法

enum RequestType{
    case get
    case post
    case put
    case delete
}

2. 关联值(Associated Values)

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

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

3. 原始值(Raw Values)

枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做:原始值

// 原始值,不写默认是枚举值
enum Grade: String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect)
print(Grade.perfect.rawValue)

4. 隐式原始值(Implicitly Assigned Raw Values)

如果枚举的原始值类型是Int、String，Swift会自动分配原始值

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

5. 递归枚举(Recursive Enumeration)

枚举值包含自己枚举,需要使用 indirect 关键字

indirect enum ArithExpr {
case number(Int)
case sum(ArithExpr, ArithExpr)
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) 

6. MemoryLayout

可以使用MemoryLayout获取数据类型占用的内存大小

 enum Password {
    case number(Int, Int, Int, Int)
    case other
}

MemoryLayout<Password>.stride // 40, 分配占用的空间大小 MemoryLayout<Password>.size // 33, 实际用到的空间大小 MemoryLayout<Password>.alignment // 8, 对齐参数

Swift 可选项

可选项

可选项，一般也叫可选类型，它允许将值设置为nil
在类型名称后面加个问号? 来定义一个可选项

1. 可选项(Optional)

实例

var name: String? = "Jack"
name = nil
var age: Int? // 默认就是nil age = 10
age = nil

2.强制解包(Forced Unwrapping)

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

• 如果为nil，那么它是个空盒子
• 如果不为nil，那么盒子里装的是:被包装类型的数据

image.png

• 如果要从可选项中取出被包装的数据(将盒子里装的东西取出来)，需要使用感叹号! 进行强制解包

var age: Int? = 10
let ageInt: Int = age!

• 如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误

var age: Int?
age!

Fatal error: Unexpectedly found nil while unwrapping an Optional value 

3.可选项绑定(Optional Binding)

可以使用可选项绑定来判断可选项是否包含值

• 如果包含就自动解包，把值赋给一个临时的常量(let)或者变量(var)，并返回true，否则返回false

if let number = Int("123") { 
    print("字符串转换整数成功:\(number)") // number是强制解包之后的Int值
    // number作用域仅限于这个大括号
} else { 
    print("字符串转换整数失败")
}
// 字符串转换整数成功:123

4.等价写法

var value = 100
if value <= 100, value >= 100, value == 100{
    print(value)
}

if value <= 100 && value >= 100 && value == 100{
    print(value)
}

5. 空合并运算符 ??

a ?? b

• a 是可选项
• b 是可选项 或者 不是可选项
• b 跟 a 的存储类型必须相同
• 如果 a 不为nil，就返回 a
• 如果 a 为nil，就返回 b
• 如果 b 不是可选项，返回 a 时会自动解包

var num: Int?
num = 10
print(num ?? 20)

6 ??跟if let配合使用

let a: Int? = nil
let b: Int? = 2
if let c = a ?? b {
    print(c) }
// 类似于if a != nil || b != nil

7. guard语句

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

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

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

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

8. 隐式解包(Implicitly Unwrapped Optional)

• 在某些情况下，可选项一旦被设定值之后，就会一直拥有值
• 在这种情况下，可以去掉检查，也不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值
• 可以在类型后面加个感叹号 ! 定义一个隐式解包的可选项

 let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
    print(num1 + 6) // 16
}
if let num3 = num1 {
    print(num3)
}