006-Swift3.0之函数

一、函数的定义和调用

// 函数的定义
func sayHello(name: String) -> String {
    let str = "Hello，" + name + "!"
    return str
}
// 函数的调用
let string = sayHello(name: "Frank")
print(string)

 

二、函数参数与返回值

1.无参数函数

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

2.多参数函数

func compareNumber(a: Int, b: Int) -> String {
    if a > b {
        return "a>b"
    } else if a == b {
        return "a=b"
    } else {
        return "a<b"
    }
}
print(compareNumber(a: 10, b: 20))

3.无返回值函数

func sayGoodbye(name: String) {
    print("Goodbye, \(name)")
}
sayGoodbye(name: "Frank")

4.返回值为元祖

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)
}
let numbers = [8, -6, 2, 109, 3, 71]
let bounds = minMax(array: numbers)
let min = bounds.min
let max = bounds.max

5.返回值为可选型元祖

func minMaxValue(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty {
        return nil
    }
    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)
}
let scoresArray: [Int] = [50, 30, 80, 99]
let minMax = minMaxValue(array: scoresArray)   // minMax类型为(min: Int, max: Int)?
if let minMax = minMax {
    print("最高分：\(minMax.max)，最低分：\(minMax.min)")
}

 

三、函数的参数标签和参数名称

每一个函数参数都有一个参数标签和一个参数名称

参数标签在调用函数时使用，参数名称在函数内部实现中使用

1.函数参数标签与参数名称为同一个

func eat(person: String, food: String) -> String {
    return "\(person)正在吃\(food)"
}
let e = eat(person: "Frank", food: "香蕉")
print(e)

2.函数参数标签与参数名称分开

空格分开，参数标签在前，参数名称在后

func drink(person name: String, what water: String) -> String {
    return "\(name)正在喝\(water)"
}
let g = drink(person: "Frank", what: "饮料")
print(g)

3.忽略参数标签

使用下划线(_)

func sortNumber(_ a: Int, _ b: Int) {
    if a > b {
        print("a>b")
    } else if a == b {
        print("a=b")
    } else {
        print("a<b")
    }
}
sortNumber(10, 30)

 

四、函数中的重难点

1.赋有默认参数值的函数

函数体中给参数赋值而定义参数默认值，调用时可忽略该参数

一般情况下，没有默认值的参数更加重要，所以一般在函数声明中将没有参数默认值的参数放在前面，而将有参数默认值的参数放在后面

func sayTo(person: String, content: String = "你好") {
    print("\(person), \(content)")
}
// 调用时再次赋值，覆盖原有的参数默认值
sayTo(person: "Frank", content: "你好帅!")  // Frank, 你好帅!
// 调用时忽略该参数
sayTo(person: "Frank")  // Frank, 你好

2.参数个数可变的函数

可变参数就是可以接受0个或多个值

可变参数的传入值在函数体内变为此类型的一个数组

func sum(_ numbers: Double...) -> Double {
    var totalSum: Double = 0
    for number in numbers {
        totalSum += number
    }
    return totalSum
}
let totalSum = sum(105, 114, 44, 185)
print("总分为：\(totalSum)")

3.参数类型为输入输出类型的函数(inout)

函数体内部可随意更改参数的值，函数调用完毕，更改值还将存在

一般的我们的函数参数都是常量类型，函数体内部是不能够去修改其值的

输入输出参数就要求我们传入的参数类型必须是变量(var)类型，需要在参数前面加上&符号

输入输出参数不能有默认值，而且参数个数可变就不能用inout标记

输入输出参数不同于返回值，它是函数对函数体外产生影响的另一种方式

func swapTwoNumbers(_ a: inout Int, _ b: inout Int) {
    let t = a
    a = b
    b = t
}
var aa = 3
var bb = 4
swap(&aa, &bb)
print("aa = \(aa)，bb = \(bb)")  // aa = 4，bb = 3

4.函数的类型

每个函数都有自己特定的函数类型

函数类型由函数的参数类型和返回值类型组成

// 函数类型为：(Int, Int) -> Int
func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
// 函数类型为：(Int, String) -> Void
func multiplyTwoInts(_ a: Int, _ b: String) {
    print("a = \(a)，b = \(b)")
}
// 函数类型为：() -> Void
func printHelloWorld() {
    print("hello, world")
}

5.定义函数类型的常量或变量

func totalSumNumbers(_ a: Int, _ b: Int) -> Int {
    return a + b
}
// 这里千万要注意，不可写成totalSumNumbers(20, 30)
// 因为函数名后面跟()，就会直接被调用，调用返回的是一个Int类型，那就不是函数类型了
var cc = totalSumNumbers  // cc为(Int, Int) -> Int类型
var dd = cc(20, 30)  // dd为Int类型

6.函数类型作为参数的函数

func printTotalSumResult(_ totalSum: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    let sum: Int = totalSum(a, b)
    print("\(a) + \(b) = \(sum)")
}
// 调用
func totalSumTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
let ss = totalSumTwoInts  // ss为(Int, Int) -> Int类型
printTotalSumResult(ss, 4, 5) // 4 + 5 = 9

7.函数类型作为返回值的函数

// 首先定义两个简单的函数
func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}
// 然后定义返回值为函数类型的函数
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}
// 函数调用
let rr = chooseStepFunction(backward: true)  // rr为(Int) -> Int类型
let tt = rr(20)  // tt = 19 tt为Int类型

8.嵌套函数

func chooseStepFunc(backward: Bool) -> (Int) -> Int {
    // 定义嵌套函数
    func stepForward(input: Int) -> Int {
        return input + 1
    }
    // 定义嵌套函数
    func stepBackward(input: Int) -> Int {
        return input - 1
    }
    return backward ? stepBackward : stepForward
}
// 调用
let rrr = chooseStepFunction(backward: true)  // rrr为(Int) -> Int类型
let ttt = rr(20)  // ttt = 19 ttt为Int类型