随着swift语言的不断发展，越来越来趋于稳定化。现在也有很多公司使用swift来开发新的App，那么不会swift开发的iOS开发者在竞争中还是很弱势的，所有学习swift是大势所趋。本系列文章根据以往的学习积累和项目经验，从基础到原理详细说说swift的这点事儿，不喜勿喷，交流指正请加微信。
一. 函数的定义
有返回值
func text() -> Double {
return 3.1415926
}
func sum(v1: Int,v2: Int) -> Int {
return v1+v2;
}
// 调用
sum(v1: 10, v2: 20)
形参默认是let，也只能是let
无返回值
// 无返回值
func sayHello() -> Void {
print("Hello")
}
返回元组：实现多返回值
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
二. 参数标签
修改参数标签
func goToWork(at time: String) {
print("this time is \(time)")
}
goToWork(at: "08:00")
// this time is 08:00
使用下划线 _ 省略参数标签
func sum(_ v1:Int, _ v2: Int) -> Int {
return v1 + v2
}
sum(10, 20)
三. 默认参数值
设置参数默认值
func check(name: String = "nobody", age: Int, job: String = "none") {
print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
check(name: "Rose", age: 18) // name=Rose, age=18, job=none
check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman
check(age: 15) // name=nobody, age=15, job=none
注意： C++的默认参数值有个限制：必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制 n 但是在省略参数标签时，需要特别注意，避免出错。
middle
// 这里的middle不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30) { }
test(middle: 20)
四：可变参数
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")
五. 输入输出参数
可以用inout定义一个输入输出参数：可以在函数内部修改外部实参的值
var number = 10
func test(_ num: Int) {
num = 20
}
test(number)
原理分析：
swapValues(&num1, &num2) 函数调用传递的是地址传递还是值传递，inout 这个函数内部是怎么实现的呢？打上断点，汇编代码如下：
点击下一步进入test函数内部
总结: 输入输出函数底层其实就是地址传递，将外部number的地址传给函数，然后再给number进行赋值。
为了更好地验证这个问题，将代码做以下修改
var number = 10
func test(_ num: Int) {
}
test(number)
然后将汇编代码进行对比以下
var number = 10
func test(_ num: Int) {
}
test(number)
0x100000f5e <+78>: movq -0x30(%rbp), %rdi
0x100000f62 <+82>: callq 0x100000f70 ; TestSwift.test(Swift.Int) -> () at main.swift:24
var number = 10
func test(_ num: inout Int) {
}
test(&number)
0x100000f47 <+55>: leaq 0x10ca(%rip), %rdi ; TestSwift.number : Swift.Int
0x100000f4e <+62>: callq 0x100000f70 ; TestSwift.test(inout Swift.Int) -> () at main.swift:24
可以看到正常的传值函数都是movq，值传递。input 是leaq传递，地址传递。movq就是通过取件码找快递，而leaq就是找到取件码
注意点：
1. 可变参数不能标记为inout
2. inout参数不能有默认值
3. inout参数只能传入可以被多次赋值的
4. inout参数的本质是地址传递（引用传递）
六. 函数重载
规则
函数名相同
参数个数不同 || 参数类型不同 || 参数标签不同
// 例子
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: Double, v2: Int) -> Double {
v1 + Double(v2)
} // 参数类型不同
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
} // 参数标签不同
func sum(a: Int, b: Int) -> Int {
a + b
} // 参数标签不同
函数重载注意点
返回值类型与函数重载无关
默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在C++中会报错）
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(v1:Int, v2: Int, v3: Int = 10) -> Int {
v1 + v2 + v3
}
// 会调用sum(v1: Int, v2: Int)
sum(v1: 10, v2: 20)
可变参数、省略参数标签、函数重载一起使用产生二义性时，编译器有可能会报错
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
// error: ambiguous use of 'sum'
sum(10, 20)
七：内联函数
内联函数在C++这个函数里是有的，那么在swift里面，怎么做的呢？swift内是不需要我们去声明这个函数为内联函数的。
如果开启了编译器优化(Realease 模式默认会开启优化)，编译器会自动将某些函数变成内联函数。
我们打开项目。
选择target---> Build Settings ---> 输入optimization 如下图:
搜索一下，我们会看到有一个Optimization Level 优化级别，默认Debug情况下是NO Optimization（没有优化）。Release(打包的时候)是Optimization for Speed[-D]是有优化的。而且是speed是最快的，按照速度最快的方式去优化。如果我们开启了优化的话，它会自动将我们的某些函数变成内联函数。也就是说，Debug模式下，不会将你的函数，变成内联函数。Release就变成内联函数。Release发布版会自动将某些函数变成内联函数，也就意味这内联函数这种东西是有用的。肯定是可以优化我们程序的系统的。
内联函数作用：
实现以下代码：
func test() -> () {
print("test")
}
test()
按照我们正常的理解，当代码调用test()这个函数时，系统会开辟栈空间，给这个函数，在这个函数栈空间里面，去做它相应的事情。比如说分配局部变量，做相应的操作。
等这个函数执行完之后呢？就会将它的栈空间回收，所以这里牵扯一个栈空间的开辟跟回收的一个问题。所以，一旦调用函数就会出这个问题。
如果这段代码能够优化成这样 print("test")性能更好吗？如下图:
// func test() -> () {
print("test")
// }
// test()
因为你这个函数里面的代码，特别的少。就是做一件什么事情，打印。还不如把函数代码抽出来，让它直接打印呢？如下图：
那么，这样不是性能更高吗？内联函数就是这个意思。内联函数会自动将函数调用展开成函数体代码。说白了，是一个怎么样的函数呢？如果你这个test是一个内联函数的话，它会之间将你的函数调用，展开成函数体print("test")。这样就是一种优化，这样可以减少函数的调用开销，就不用开辟栈空间，撤销栈空间。
按照资料来说，Debug是没有优化的，Release是优化的，用汇编看一下到底有没有优化
在test()带一个断点，cmd + R 运行
test函数调用转成了汇编，如下图：
我们发现test函数被调用了，所以再debug模式下并没有没内联。我们再将这个地方改成release 模式，运行一遍。
会发现一个奇怪的现象，断点没进，但是结果已经打印出来了。所以test()这段代码并没有调用，可以打印出数据，说明print("test")这行代码肯定执行了，那么我们把断点打到print("test")位置，如下图：
汇编如图所示：
发现最上边TestSwift`main:。main函数里面就有print函数
所以，看的出来，我们一旦开启了编译器的优化，它确实会将我们的函数进行内联，直接将它函数体代码，放到这个位置test()。
并不是所有的函数都会被内联，哪些函数不会被内联呢？
函数体比较长
就是如果函数内部，写了很多的时候，它发现代码比较长，它就不会进行内联，它就不会将你的函数体代码放到调用的位置
func test() {
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
print("test1111")
}
如果这个函数调用次数比较多，假设如下图test()调用的比较多，那么你要内联的话，那不就相当于把函数里所有代码，main里面放一份，原位置放一份。生成的汇编特别多，最终的机器也就是01、01特别多，所以就会导致你代码的体积就会变大，到时候你的安装包也就会变大，所以这个也是比较智能的。编译器会自动去识别，它认为合适的就会进行内联，不合适的它不会内联，说白了，上面代码，就算你开启了编译器，编译器的优化，它也会变成函数调用，不会给你做内联优化。
包含递归调用的函数也不会内联
如果你包含了递归调用，也不会内联。如下面代码这样写：
func test() {
test()
}
test()
像这种，编译器也不会内联，内联就是将函数调用展开成函数体代码，然而函数体就这一句 test()，函数外边test()，展开后还是 test()，就是一个死循环，所以编译器也是很聪明的，发现你有递归调用也不会给你内联。
包含动态派发
什么叫动态派发呢？其实就是OC里面的动态绑定，如果包含了动态派发的函数，它也不会进行内联。
比如说，我们有两个类，一个Person类和Student类，Student类继承于Person。 Person中有一个test函数方法，子类Student，重写一下父类的test方法。如下图:
认真思考一个问题,举个例子
上边图片，的两句代码，明显是一个多态。相当于OC里面的父类指针指向子类对象。那么你想一下test这个函数这个将来肯定要动态派发的。所谓动态派发就是在运行时再决定调用谁的test。
程序运行过程中，根据你的变量指向的对象来调用谁。再举个例子，如果下面有个Teacher类
所以，你思考一下，到时候如下图，可能会变。
就是说到时候，可能会指向Teacher,既然你这个变量，将来指向的对象是随时可能会发生变化的。所以编译器在编译这个代码的时候，没办法确定到底是调用Teacher类、还是Student类中的test，所以这个叫做动态派发。没有办法进行内联。
想一想，内联的前提是什么？我已经确定要调用某个，比如说我确定在编译时期了你要调用某个类的test，那么就将函数体代码放到这个位置如下图：
这个，肯定不能内联。
关于swift的更多知识
请点击 swift文集