1. 函数的定义与调用

函数的定义

func函数名(参数变量 : 类型, 参数变量 : 类型...) -> 返回类型 {

    statements

    ......

    return 返回值

}

函数的调用

函数名(传递参数, 传递参数…)

2. 为参数设置默认值

funcsum(number1 : Int = 1, number2 : Int = 1) -> Int {

    return number1 + number2

}

let a = sum()

let b = sum(number1 : 10, number2 : 20)

print(a) // 结果 : 2

print(b) // 结果 : 30

3. 设置可变的函数参数

在定义函数的时候, 当不确定参数的具体数量的时候, 可以通过在变量后面加 "..." 从而实现可变参数

一个函数最多只能有一个可变参数, 并且必须在函数表中最后一个位置

func getAverage(numbers : Double...) -> Double {

    if numbers.count == 0 {

    return 0.0

}

var total : Double = 0.0

    for num in numbers {

        total += num

    }

    return total / Double(numbers.count)

}

var average = getAverage()

print(average) // 结果 : 0.0

average = getAverage(numbers : 1, 2, 3, 4, 5, 6)

print(average) // 结果 : 3.5

4. 使用函数类型

使用函数类型就和使用其他的类型一样, 可以直接将一个函数赋值给另外一个函数

func getTotal(number1 : Int, number2 : Int) -> Int {

    return number1 + number2

}

let function : (Int, Int) -> Int = getTotal

let result = function(1, 2)

print(result) // 结果 : 3

let newFunction = getTotal

let newResult = newFunction(2,3)

print(newResult) // 结果 : 5

当函数没有参数并且没有返回值的时候 :

func printHelloSwift() {

    print("Hello, Swift!")

}

let Print : () -> () = printHelloSwift

Print() // 结果 : Hello, Swift!

let newPrint = printHelloSwift

newPrint() // 结果 : Hello, Swift!

5. 函数作为参数和返回类型

func getSmaller(number1 : Int, number2 : Int) -> Int {

    return (number1 > number2) ? number2 : number1

}

func getBigger(number1 : Int, number2 : Int) -> Int {

    return (number1 > number2) ? number1 : number2

}

func printMathResult(mathFunction : (Int,Int) -> Int, number1 : Int, number2 : Int) {

    print("The result is \(mathFunction(number1, number2))")

}

let a : Int = 1

let b : Int = -1

printMathResult(mathFunction : getSmaller, number1 : a, number2 : b)

printMathResult(mathFunction : getBigger, number1 : a, number2 : b)

    /*结果 :

        The result is -1

        The result is 1

    */

6. 函数作为返回类型

func getSmaller(number1 : Int, number2 : Int) -> Int {

    return (number 1 > number2) ? number2 : number1

}

funcgetBigger(number1 : Int,number2 : Int) -> Int {

    return (number 1 > number2) ? number1 : number2

}

func chooseFunction(needBigger : Bool) -> (Int, Int) -> Int {

    return needBigger ? getBigger : getSmaller

}

let function = chooseFunction(needBigger : true)

let a = function(1, 2)

print(a) // 结果 : 2

7. 利用元组作为函数的返回值

当一个函数需要返回多个值的时候, 可以利用元组来返回多个值

func getUserInformation(userId : String) -> (userName : String, userLevel : Int, userPhoto : String) {

    let userName = "John"

    let userLevel = 1

    let userPhoto = "https://www.jonny.vip/userPhoto/bf293872f.jpeg"

    return (userName, userLevel, userPhoto)

}

let message = getUserInformation(userId : "10000")

print(message.0)

print(message.1)

print(message.2)

    /*结果 :

        John

        1

        https://www.jonny.vip/userPhoto/bf293872f.jpeg

    */

8. 函数的输入输出参数

当想要一个函数可以修改参数的值, 并且在这些函数结束调用之后仍然存在, 那么可以将参数定义为输入输出参数, 可以在这些参数类型前面添加 inout 关键字实现

同时, 传入函数的参数只能是变量不能是常量, 当传入的参数作为输入输出参数时, 需要在参数前面加上 "&" 符号, 表示这个参数值是可以被函数修改并且函数结束之后修改后的值会被保留

func swap(preNumber : inout Double, nextNumber : inout Double) {

    let tempNumber = preNumber

    preNumber = nextNumber

    nextNumber = tempNumber

}

var preNumber = 2, nextNumber = 1

print("交换之前 : ")

print(preNumber)

print(nextNumber)

swap(&preNumber, &nextNumber)

print("交换之后 : ")

print(preNumber)

print(nextNumber)

    /*结果 :

        交换之前 :

        2

        1

        交换之后 :

        1

        2

    */

9. 函数的嵌套与递归

函数的嵌套

被嵌套的子函数只能在其父函数的内部使用, 在父函数的外部是无法被调用的

func chooseNumber(needBigger : Bool, number1 : Int, number : Int) {

    func getSmaller() {

        print((number1 < number2) ? number1 : number2)

    }

    func getBigger() {

        print((number1 > number2) ? number1 : number2)

    }

    needBigger ? getBigger : getSmall

}

函数的递归

理论上所有递归函数都可以被写成循环的方式, 但是递归函数比循环更加简单并且逻辑清晰

func recursion(number : Int) -> Int {

    if n <= 1 {

        return 1

    }

    else {

        return recursion(number : number - 1) + recursion(number : number - 2)

    }

}

let num = recursion(number : 5)

print(num) // 结果 : 8

10. Swift 中常用的内置函数

abs 绝对值函数

print(abs(-1)) // 结果 : 1

min 最小值函数

print(min(8, 2, 3)) // 结果 : 2

max 最大值函数

print(max(8, 2, 3, 4)) // 结果 : 8

filter 函数

filter 函数通常用于查找在数组中的满足指定条件的元素

foriin(1...10).filter({$0 % 3 == 0}){

    print(i)

}

    /*结果 : 

        3

        6

        9

    */

map 函数

map 函数通常用于将数组中的每个元素通过指定的方法进行转换

foriin(1...3).map({$0 * 3}){

    print(i)

}

    /*结果 :

        3

        6

        9

    */

reduce 函数

reduce 函数可以把数组元素组合计算为一个值

let result = (1...4).reduce(0,{$0 + $1})

print(result) // 结果 : 10

let newResult = (1...4).reduce(0, +)

print(newResult) // 结果 : 10

let result2 = (1...4).reduce(1, *)

print(result2) // 结果 : 24