06：swift-函数

 

 

正文

{
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.title = "6:函数"
        self.view.backgroundColor = UIColor.white

        // 2：调用函数
        let str1 = greet(person: "张珊")
        print(str1)
        
        // 3: 多函数返回值 元组
        let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
        print("min is \(bounds.min) and max is \(bounds.max)")
        
        // 4: 可选项元组返回值 可选项绑定
        if let bounds = minMaxOptional(array: [8, -6, 2, 109, 3, 71]) {
            print("min is \(bounds.min) and max is \(bounds.max)")
        }
        
        // 5:实际参数，形式参数
        print(greet(person: "Bill", from: "Cupertino"))
        
        // 6: 输入输出形式参数
        var someInt = 3
        var anotherInt = 107
        swapTwoInts(&someInt, &anotherInt)
        print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
        // prints "someInt is now 107, and anotherInt is now 3"
        
        // 7: 函数类型
        
        // 8：函数类型作为参数
        printMathResult(addTwoInts, 3, 5)
        
        // 9：函数作为返回值
        var currentValue = 3
        let moveNearerToZero = selectFunc(directionForward: currentValue > 0)
        let result = moveNearerToZero(3)
        print("函数返回值：\(result)")
        
        // 10:内嵌函数
        var currentValue1 = -4
        let moveNearerToZero1 = chooseStepFunction(backward: currentValue > 0)
        let result1 = moveNearerToZero(currentValue1)
        print("内嵌函数返回值：\(result1)")
    }
    
    /* 6：函数
     1：定义函数
     2：调用函数
     3：多个返回值 元组
     4：可选元组返回值类型 可选项绑定
     5：实际参数名、形式参数名
     6：输入输出形式参数
     7：函数类型
     8：函数作为输入参数
     9：函数作为输出参数
     10: 内嵌函数
     */
    
    // 1：定义函数
    private func greet(person: String) -> String {
        let greeting = "Hello, " + person + "!"
        return greeting
    }
    
    // 3: 多返回值的函数 元组
    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)
    }
    
    // 4:可选元组返回类型
    func minMaxOptional(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)
    }
    
    // 5:函数实际参数标签和形式参数名
    // 实际参数标签的使用能够让函数的调用更加明确，更像是自然语句，同时还能提供更可读的函数体并更清晰地表达你的意图。
    func greet(person: String, from hometown: String) -> String {
        return "Hello \(person)!  Glad you could visit from \(hometown)."
    }
    
    // 6：输入输出形式参数 inout 关键字
    // 在形式参数定义开始的时候在前边添加一个 inout关键字可以定义一个输入输出形式参数。输入输出形式参数有一个能输入给函数的值，函数能对其进行修改，还能输出到函数外边替换原来的值。
    func swapTwoInts(_ a: inout Int, _ b: inout Int) {
        let temporaryA = a
        a = b
        b = temporaryA
    }
    
    /* 7: 函数类型
     由形式参数类型，返回类型组成。
     (Int, Int) -> Int 。也读作：
     “有两个形式参数的函数类型，它们都是 Int类型，并且返回一个 Int类型的值。”
     
     -> 可以认为是return
     */
    // 声明一个变量是：函数类型

    func addTwoInts(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
    
   // 8：函数类型作为参数
    func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
        print("Result: \(mathFunction(a, b))")
    }
    
    // 9: 函数类型作为返回值
    func stepForward(_ input: Int) -> Int {
        return input + 1
    }
    
    func stepBackward(_ input: Int) -> Int {
        return input - 1
    }
    
    // 选择方向
    func selectFunc(directionForward: Bool) -> (Int) -> Int {
        if directionForward {
            return stepForward
        } else {
            return stepBackward
        }
    }

    // 10：内嵌函数
    func chooseStepFunction(backward: Bool) -> (Int) -> Int {
        func stepForward(input: Int) -> Int { return input + 1 }
        func stepBackward(input: Int) -> Int { return input - 1 }
        return backward ? stepBackward : stepForward
    }
}