Swift学习－函数（六）

这章就以代码的方式记录了，力求做到：简洁、完整。

 //带参数 返回值的函数

        func sayHello(_ personName:String) ->String

        {

            let greeting = "Hello, " + personName + "!"

            return greeting

        }

        print(sayHello("feng"))

        

        //多个参数

        func halfOpenRangeLength(start:Int, end:Int) ->Int

        {

            return end - start

        }

        

        print(halfOpenRangeLength(start: 1, end:10))//9

        

        //没参数到函数

        func sayHelloWorld() ->String

        {

            return"Hello, world"

        }

        

        //没有返回值的函数－其实是返回特殊值void（是一个空元组（））

        func sayGoodBye(personName:String)

        {

            print("Goodbye,\(personName)")

        }

        

        //通过元组返回多个值

        func minMax(_ array:[Int]) -> (min:Int, max:Int)

        {

            var currentMin = array[0]

            var currentMax = array[0]

            //array[1..<array.cout]返回范围内的值构成的新数组

            for value in array[1..<array.count]{

                if value < currentMin

                {

                    currentMin = value

                    

                }else if value > currentMax

                {

                    currentMax = value

                }

            }

            return (currentMin, currentMax)

        }

        let bounds = minMax([8,-6,2,109,3,71])

        print("min is\(bounds.min) and max is\(bounds.max)")

        //min is -6 and max is 109

        

        //可选元组返回类型,(Int,Int)?与元组包含可选属性如(Int?, Int?)不同。前者是整个元组是可选的

        func minMaxOptional(_ array:[Int]) -> (min:Int, max:Int)? {

            if array.isEmpty {return nil}

            var currentMin = array[0]

            var currentMax = array[0]

            //array[1..<array.cout]返回范围内的值构成的新数组

            for value in array[1..<array.count]{

                if value < currentMin

                {

                    currentMin = value

                    

                }else if value > currentMax

                {

                    currentMax = value

                }

            }

            return (currentMin, currentMax)

        }

        if let bounds = minMaxOptional([8,-8,2,110,3,71])

        {

            print("min is\(bounds.min) and max is\(bounds.max)")

        }

        //min is -8 and max is 110

        

        //外部参数名

        func someFunction(to person:String, and anotherPerson:String)->String

        {

            return"Hello\(person) and\(anotherPerson)!"

        }

        print(someFunction(to:"feng", and:"liu"))//Hello feng and liu!

        //   忽略第二个及后续的参数设置的参数名，用下划线（_）代替

        func someFunction1(_ firstParameterName:Int,_ senondParameterName:Int)->Int

        {

            return firstParameterName + senondParameterName

        }

        //调用不需要参数名

        print(someFunction1(2,2))//4

        

        // 带默认参数的函数

        func someFunction2(_ parameterWithDefault:Int = 12)

        {

            print(parameterWithDefault)

        }

        someFunction2() //12

        someFunction2(5)//5

        

        /*使用（...）来定义可变参数接受0个或多个值

         Double... 相当于 Double[]数组

         函数最多有一个可变参数，为避免歧义一般写在参数列表的最后

         如果函数有多个默认值，可变参数也放在参数列表最后

         */

        func arithmeticMean(_ numbers:Double...) ->Double

        {

            var total:Double = 0

            for number in numbers

            {

                total += number

            }

            return total / Double(numbers.count)

        }

        print(arithmeticMean(1,2,3,4,5))// 3.0

        

        //函数默认参数为常量，不能更改值。

        // 可变参数已经在swift4中不可用

        func alignRight( _ string:String, totalLength:Int, pad:Character)->String

        {

            //用var声明一个可变变量数(其生命周期只存在于函数体)

            var string = string

            let amountToPad = totalLength - string.count

            if amountToPad < 1

            {

                return string

            }

            let padString = String(pad)

            for _ in 1...amountToPad

            {

                    string = padString + string

            }

            return string

        }

        let originalString = "hello"

        let paddedString = alignRight(originalString, totalLength:10, pad: "-")

        print(paddedString)//-----hello

        

        //inout 定义输入输出参数

        func swapTwoInts( a:inout Int,  b:inout Int)

        {

            let temporaryA = a

            a = b

            b = temporaryA

        }

        var someInt = 3

        var anotherInt = 100

        //传入参数是需要前面加"&"，表示变量可以修改

        swapTwoInts(a: &someInt, b: &anotherInt)

        print("someInt:\(someInt),anotherInt:\(anotherInt)")//someInt:100,anotherInt:3

        

        //函数类型(有函数参数类型和返回值类型组成)例如（Int,Int） -> Int

        func addTwoInts(a:Int,_ b:Int)->Int

        {

            return a + b

        }

        func multiplyTwoInts(a:Int,_ b:Int)->Int

        {

            return a * b

        }

        func operatorIns(a:Int,_ b:Int,_ c:Int)->Int

        {

            return a + b + c

        }

        //函数赋值给变量

        var mathFunction:(Int,Int)->Int = addTwoInts

        print("Result:\(mathFunction(2,3))")//Result:5

        mathFunction = multiplyTwoInts

        print("Result:\(mathFunction(2,3))")//Result:6

        

        //报错 参数不一样 mathFunction已经是(Int,Int） -> Int

        //mathFunction = operatorIns

        //函数类型被swift推测

        var anotherMathFunction = addTwoInts

        print("anotherResult:\(anotherMathFunction(5,10))")//anotherResult:15

        

        //函数类型作为参数

        func printMathResult(_ mathFunction:(Int,Int)->Int,_ a:Int, _ b:Int)

        {

            print("Result:\(mathFunction(a,b))")

        }

        printMathResult(addTwoInts,3,5)//Result: 8

        

        //函数作为返回类型（“—>”后写完整的函数类型（如（Int）-> (Int)））

        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

        }

        /*嵌套函数

         把函数定义在函数体中称为嵌套函数

         对外不可见，可别他们的封闭函数调用。

         封闭函数也可以返回他的一个嵌套函数

         */

        func chooseStepFunction1(backwards:Bool) -> (Int)->Int

        {

            func stepForward(input:Int) ->Int {return input + 1}

            func stepBackward(input:Int) ->Int {return input - 1}

            return backwards ?stepBackward :stepForward

        }

        var currValue = -4

        let moveNearToZero = chooseStepFunction1(backwards: currValue > 0)

        while currValue != 0 {

            print("\(currValue)...")

            currValue = moveNearToZero(currValue)

        }

        print("Zero!")

        //-4...

        //-3...

        //-2...

        //-1...

        //Zero!