1、函数声明和调用

通用函数声明格式：func 函数名称（形参名：形参类型，形参名：形参类型，···）->返回值类型{}

func doSum(num1: Int, num2: Int) -> Int{
    return num1 + num2
}
print(doSum(num1: 1, num2: 1))

可以用-来省略形参标签

func doSum1(_ num1: Int, _ num2: Int) -> Int {
    return num1 + num2
}
print(doSum1(1, 1))

可以用at来修改参数标签

func doSum2(at num1: Int, at num2: Int) -> Int {
    return num1 + num2
}
print(doSum2(at: 1, at: 1))

无返回函数的几种写法

func test (v1 : Int, v2: Int) ->(Void) {
    
}
func test1 (v1 : Int, v2: Int) ->() {
    
}
func test2 (v1 : Int, v2: Int){
    
}

返回值是元组类型（可以实现多返回）

// 计算后返回：和、差、平均
func calculate(num1: Int, num2: Int) -> (sum: Int, difference: Int, average: Int) {
    let sum = num1 + num2
    return (sum, num1 - num2, sum >> 1)
}
let result = calculate(v1: 20, v2: 10)
print(result.sum,result.difference,result.average)
//输出结果30 10 15

2、可变参数

func doSums (nums: Int ...) -> Int {
    var sum = 0
    for num in nums {
        sum = sum + num
    }
    return sum
}

print(doSums(nums: 1,3,4,5))
//输出 13

func doSums (nums: Int ..., string: String, _ string1: String) -> Int {
    var sum = 0
    for num in nums {
        sum = sum + num
    }
    return sum
}

print(doSums(nums: 1,3,4,5,string:"string","string1"))

注意：

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

3、输入输出参数

定义：在形式参数定义开始的时候在前边添加一个 inout关键字可以定义一个输入输出形式参数
作用：可以在函数内部修改外部实参的值

var v1 = 10
var v2 = 11

func changeVale(_ v1: inout Int, _ v2: inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
}

changeVale(&v1, &v2)
print(v1,v2)
//输出是11，12

注意：

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

4、内联函数

是一种编译器优化技术，它通过使用方法的内容替换直接调用该方法，从而优化性能。

swift编译优化设置.png

debug默认编译器不优化
release 是基于速度的优化

@inline关键字

@inline(__always).png
当添加@inline(__always)关键字后，发现断点直接不走，控制台直接输出结果2 @inline(never).png
在release编译器优化下，不添加@inline(never)关键字断点是不会走的，添加之后断点会走

总结

• @inline(__always) 将确保始终内联函数
• @inline(never) 将确保永远不会内联函数

5、函数类型

每个函数都有自己的函数类型，函数类型由函数的参数类型和返回值类型决定

//函数类型是（Int，Int）-> Int
func doSum1(_ num1: Int, _ num2: Int) -> Int {
    return num1 + num2
}

//函数类型是（Int，Int）-> void
func test(_ num1: Int, _ num2: Int) -> (void) {

}

函数类型作为函数参数

func doSum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}
func difference(num1: Int, num2: Int) -> Int {
    return num1 - num2
}
// (Int,Int) -> Int此处就是一个函数类型
func result(_ afunc : (Int,Int) -> Int, _num1 : Int, _num2: Int) {
    let temp = afunc(_num1,_num2)
    print(temp)
}
result(doSum(num1:num2:), _num1: 3, _num2: 2)//5
result(difference(num1:num2:), _num1: 3, _num2: 2)//1

函数类型作为函数返回值

func doSum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}

func difference(num1: Int, num2: Int) -> Int {
    return num1 - num2
}
//(Int,Int) -> Int此处就是一个函数类型
func result(_ isDoSum: Bool) ->(Int,Int) -> Int {
   return isDoSum ? doSum(num1:num2:) : difference(num1:num2:)
}
let r = result(true)(3,2)//5
let r1 = result(false)(3,2)//1

6、嵌套函数

将函数定义在函数内部（不想暴露内部函数）

func result1(_ isDoSum: Bool) ->(Int,Int) -> Int {
    func doSum(num1: Int, num2: Int) -> Int {
        return num1 + num2
    }

    func difference(num1: Int, num2: Int) -> Int {
        return num1 - num2
    }
   return isDoSum ? doSum(num1:num2:) : difference(num1:num2:)
}

let r1 = result(false)(3,2)//1
let r1 = result(true)(3,2)//5