image.png

简易函数

func transfer(value : Double) -> Double {
    return value + Double(1)
}
print(transfer(value: 10))

• 形参默认是let，也只能是let
• 无返回值 ->Void ->() 或者没有->也可以

隐式返回

无需return

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

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

元组返回

实现多返回值

func calculate(v1: Int,v2: Int) -> (sum:Int,difference:Int,average:Int) {
    let sum = v2 + v1
    return (sum,v1 - v2, v1 * v2)
}
let result = calculate(v1: 10, v2: 20).sum
print(result)

函数注释

image.png

参数标签（Argument Label）

func goToWork(time:String) -> Void {
    print("this time is \(time)")
}
goToWork(time: "2020年11月17日 13:31:29")
func goToWork1(at time:String) -> Void {
    print("this time is \(time)")
}
goToWork1(at: "2020年11月17日 13:31:29")
func goToWork2(_ time:String) -> Void {
    print("this time is \(time)")
}
goToWork2("2020年11月17日 13:31:29")

image.png

• _省略参数标签

默认参数值 Default Parameter Value

image.png

func check(name:String = "noBody",age:Int,job:String = "none") -> Void {
    print("name=\(name),age=\(age),job=\(job)")
}
check(age: 10)
check(name: "wpp", age: 27, job: "iOS")
check(name:"mosi",age: 20)

image.png

• 省略标签注意别出错

可变参数

func sum(numbers: Int...) -> Int {
    var total = 0
    for i in numbers {
        total = i + total
    }
    return total
}
print(sum(numbers: 1,2,3,4,5))

• 一个函数最多只能有一个可变参数
• 紧跟着可变参数后面 后面的参数不能省略参数_哦！

输入输出参数 In Out Parameter

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

func swapValues(v1:inout Int,v2:inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
    
}
var v1 = 10,v2 = 20
print("v1 = \(v1),v2 = \(v2)")
swapValues(v1: &v1, v2: &v2)
print("v1 = \(v1),v2 = \(v2)")

• inout 参数本质是地址传递（引用传递）
• inout 不能有默认值
• 可变参数不能标记inout
• inout只能传入

函数重载 (Function Overload)

• 函数名相同
• 参数个数不同/参数类型不同/参数标签不同
• 返回值类型和重载无关

func total(v1: Int ,v2: Int,v3: Int = 10) -> Int {
    v1 + v2 + v3
}
print(total(v1: 10, v2: 10))
print(total(v1: 10, v2: 10, v3: 10))

控制体打印：
30
30


func total(v1: Int ,v2: Int) -> Int {
    v1 + v2
}
func total(v1: Int ,v2: Int,v3: Int = 10) -> Int {
    v1 + v2 + v3
}
print(total(v1: 10, v2: 10))
print(total(v1: 10, v2: 10, v3: 10))
控制体打印：
20
30

• 默认参数和函数重载一起使用会产生二义性编译器不会报错（C++会报错）
• 可变参数、省略参数、函数重载一起产生二义性编译器可能会报错

内联函数 Inline Function

无需关注

print("内联函数 Inline Function")
//* 如果开启了编译器优化（Release模式默认会开启优化），编译器会自动将某些函数变成内联函数
//* 将函数调用展开成函数体
//* 永远不会被内联（即使开启了编译器优化）
@inline(never) func test() {
    print("test")
}
//* 开启编译器优化后，即使嗲吗很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test1() {
    print("test1")
}
test()
//* 在Release模式下，编译器已经开启优化，会自动决定哪些喊出需要内联，因此没必要使用@inline

函数类型

• 每一个函数都是有类型的，函数类型由形式参数类型、返回值型组成

func task() {
    
}
//() - > Void      () -> ()
func task(a: Int,b: Int) -> Int {
    a + b
}
//(Int,Int) -> Int
print(task(a: 10, b: 20))
//调用时不需要参数标签
var fnnnnn:(Int,Int) -> Int = task
print(fnnnnn(10,20))

函数作为参数、返回值

• 作为参数

func pp(v1: Int,v2: Int) -> Int {
    v1 + v2
}
func pp1(v1: Int,v2: Int) -> Int {
    v1 - v2
}
func pp2(fn:(Int,Int) -> Int,a: Int,b: Int) {
    print("result:\(fn(a,b))")
}
func pp2(_ fn:(Int,Int) -> Int,_ a: Int,_ b: Int) {
    print("result:\(fn(a,b))")
}
pp2(fn: pp, a: 20, b: 30)
pp2(fn: pp1, a: 50, b: 30)
pp2(pp, 20, 30)

• 返回值

func pp3() -> (Int,Int) -> Int {
    pp
}
print(pp3()(20,30))

嵌套函数

和函数作为返回值差不多意思

func pp4(_ forward:Bool) -> (Int) -> Int {
    func next(_ input: Int) -> Int {
        input + 1
    }
    func previous(_ input: Int) -> Int {
        input - 1
    }
    return forward ? next : previous
}
print(pp4(true)(2))

配合typealias

typealias byte = Int8
let a:byte = 8
print(a)

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

func setFn(_ fn:IntFn) -> Void {
    
}
func getFn() -> IntFn {
    difference
}
print(fn(20,10))

补充 (Function)

函数作为参数函数类型的时候 绑定函数

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

下面打印sum

print(sum)

(Function)

如果函数是重载函数则不行

image.png

Ambiguous use of 'sum'：“sum”用法不明确