随着swift语言的不断发展，越来越来趋于稳定化。现在也有很多公司使用swift来开发新的App，那么不会swift开发的iOS开发者在竞争中还是很弱势的，所有学习swift是大势所趋。本系列文章根据以往的学习积累和项目经验，从基础到原理详细说说swift的这点事儿，不喜勿喷，交流指正请加微信。

WeChatdfdb8bfa7f0a84545d010ef18af70a98.png

一. 函数的定义

有返回值

    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函数内部

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 如下图:

image.png

搜索一下，我们会看到有一个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函数汇编图

我们发现test函数被调用了，所以再debug模式下并没有没内联。我们再将这个地方改成release 模式，运行一遍。

WX20200831-211506@2x.png

会发现一个奇怪的现象，断点没进，但是结果已经打印出来了。所以test()这段代码并没有调用，可以打印出数据，说明print("test")这行代码肯定执行了，那么我们把断点打到print("test")位置，如下图：

WX20200831-211557@2x.png

汇编如图所示：

WX20200831-212048@2x.png

发现最上边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方法。如下图:

2156697-4a7d1f9c804470c9.png

认真思考一个问题,举个例子

2156697-9f9d6746a851a27c.png

上边图片，的两句代码，明显是一个多态。相当于OC里面的父类指针指向子类对象。那么你想一下test这个函数这个将来肯定要动态派发的。所谓动态派发就是在运行时再决定调用谁的test。

程序运行过程中，根据你的变量指向的对象来调用谁。再举个例子，如果下面有个Teacher类

2156697-520c4d936f2d2b54.png

所以，你思考一下，到时候如下图，可能会变。

2156697-0634c2e50a23bba9.png

就是说到时候，可能会指向Teacher,既然你这个变量，将来指向的对象是随时可能会发生变化的。所以编译器在编译这个代码的时候，没办法确定到底是调用Teacher类、还是Student类中的test，所以这个叫做动态派发。没有办法进行内联。

想一想，内联的前提是什么？我已经确定要调用某个，比如说我确定在编译时期了你要调用某个类的test，那么就将函数体代码放到这个位置如下图：

2156697-421136b6ba015a79.png

这个，肯定不能内联。

关于swift的更多知识
请点击 swift文集