函数是一个独立的代码块，用来执行特定的任务。通过给函数一个名字来定义它的功能，并且在需要的时候，通过这个名字来“调用”函数执行它的任务。

函数的形式参数和返回值

在 Swift 中，函数的形式参数和返回值非常灵活。你可以定义从一个简单的只有一个未命名形式参数的工具函数到那种具有形象的参数名称和不同的形式参数选项的复杂函数之间的任何函数。

有返回值

func sayHelloWorld() -> String {
    return "hello, world"
}

形参默认是let，也只能是let

无返回值

func sayHelloWorld() -> Void {
    print("hello, world")
}


func sayHelloWorld() -> () {
    print("hello, world")
}

func sayHelloWorld(){
    print("hello, world")
}

隐式返回

如果整个函数体是一个单一表达式，那么函数隐式返回这个表达式。也就是函数只有一个表达式的时候，不用return

func sum(v1:Int,v2:Int) -> Int {
    v1+v2
}
print(sum(v1: 1, v2: 2))

返回元组：实现多返回值

为了让函数返回多个值作为一个复合的返回值，你可以使用元组类型作为返回类型。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

函数的文档注释

/// 求和【概述】
/// - Parameter v1: 第一个整数
/// - Parameter v2: 第二个整数
/// - Note:传入两个整数即可【批注】
func sum(v1:Int,v2:Int) -> Int {
    v1+v2
}

文档注释.png

参数标签

每一个函数的形式参数都包含实际参数标签和形式参数名。实际参数标签用在调用函数的时候；在调用函数的时候每一个实际参数前边都要写实际参数标签。形式参数名用在函数的实现当中。默认情况下，形式参数使用它们的形式参数名作为实际参数标签。

func goToWork(time:String) {
    print("this time is \(time)")
}
goToWork(time: "10点")



func goToWork(at time:String) {
    print("this time is \(time)")
}
goToWork(at: "10点")

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

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

默认参数值

你可以通过在形式参数类型后给形式参数赋一个值来给函数的任意形式参数定义一个默认值。如果定义了默认值，你就可以在调用函数时候省略这个形式参数。

把不带有默认值的形式参数放到函数的形式参数列表中带有默认值的形式参数前边，不带有默认值的形式参数通常对函数有着重要的意义——把它们写在前边可以便于让人们看出来无论是否省略带默认值的形式参数，调用的都是同一个函数。

func check(name:String = "tom",age:Int,job:String = "none"){
    print("name is \(name),age is \(age), job is \(job)")
}

check(age: 10)
check(name: "kk", age: 20, job: "IT")
check(name: "aa", age: 30)
check(age: 25, job: "Teacher")

可变参数

一个可变形式参数可以接受零或者多个特定类型的值。当调用函数的时候你可以利用可变形式参数来声明形式参数可以被传入值的数量是可变的。可以通过在形式参数的类型名称后边插入三个点符号（ ...）来书写可变形式参数。

func sum(_ numbers:Int...) -> Int{
    var total = 0
    for item in numbers {
        total += item
    }
    return total
}

Swift自带的print函数

/// - Parameters:
///   - items: Zero or more items to print.
///   - separator: A string to print between each item. The default is a single
///     space (`" "`).
///   - terminator: The string to print after all items have been printed. The
///     default is a newline (`"\n"`).
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")

• 第一个参数：就是需要打印的值，是一个可变参数
• 第二个参数：两个打印值连接的地方，默认是空格
• 第三个参数：结尾默认是\n换行

输入输出参数

可变形式参数只能在函数的内部做改变。如果你想函数能够修改一个形式参数的值，而且你想这些改变在函数结束之后依然生效，那么就需要将形式参数定义为输入输出形式参数。

在形式参数定义开始的时候在前边添加一个 inout关键字可以定义一个输入输出形式参数。输入输出形式参数有一个能输入给函数的值，函数能对其进行修改，还能输出到函数外边替换原来的值。

你只能把变量作为输入输出形式参数的实际参数。你不能用常量或者字面量作为实际参数，因为常量和字面量不能修改。在将变量作为实际参数传递给输入输出形式参数的时候，直接在它前边添加一个和符号 ( &) 来明确可以被函数修改。

var b = 10
func test(a:inout Int) {
    a = 20
}
test(a: &b)
print(b) //20

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

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

函数重载

规则

• 函数名相同
• 参数个数不同或者参数类型不同或者参数标签不同

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

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

func sum(v1:String,v2:String) -> String {
    v1 + v2
}

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

内联函数

• 如果开启了编译器优化（Release默认开始优化），编译器回自动将某些函数变成内联函数
• 内联函数就是把函数调用，展开成函数题

//开启前
func test() {
    print("内联函数")
}

test()

//开启后
 print("内联函数")

哪些函数不会被自动内联

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

内联函数.png

函数类型

每一个函数都有一个特定的函数类型，它由形式参数类型，返回类型组成。

你可以像使用 Swift 中的其他类型一样使用函数类型。例如，你可以给一个常量或变量定义一个函数类型，并且为变量指定一个相应的函数。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}

var mathFunction: (Int, Int) -> Int = addTwoInts
print(mathFunction(1,2))

这可以读作：
定义一个叫做 mathFunction的变量，它的类型是一个能接受两个 Int值的函数，并返回一个 Int值。将这个新的变量指向 addTwoInts函数。

函数类型可以作为函数的参数

func sum(a:Int,b:Int) -> Int {
    a + b
}
func reduction(a:Int,b:Int) -> Int {
    a - b
}

func printResult(_ mathFn:(Int,Int) -> Int, a:Int, b:Int) {
    print(mathFn(a,b))
}

printResult(sum, a: 3, b: 2)
printResult(reduction, a: 3, b: 2)

函数类型作为函数返回值

func next(_ input:Int) -> Int {
    input + 1
}

func previous(_ input:Int) -> Int {
    input - 1
}

func forward(_ forward:Bool) -> (Int) -> Int {
    forward ? next : previous
}

print(forward(true)(3))  // 4
print(forward(false)(3))  // 2

返回值是函数类型的函数叫做高阶函数

typealias别名

按照swift标准库的定义Void就是一个空元组

public typealias Void = ()

我们知道swift中没有byte、short、Long类型，如果我们想要这样的类型，就可以用typealias实现

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

我们还可以给函数起一个别名

typealias IntFn = (Int,Int) -> Int
func difference(v1:Int,v2:Int) -> Int {
    v1 - v2
}
let fn:IntFn = difference
print(fn(2,1))  //1

我们还可以给元组起别名

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

嵌套函数

将函数定义在函数的内部

func forward(_ forward:Bool) -> (Int) -> Int {
    
    func next(_ input:Int) -> Int {
        input + 1
    }

    func previous(_ input:Int) -> Int {
        input - 1
    }
    
    return forward ? next : previous
}