swift学习笔记 -- Functions

一 定义和调用函数

    func 函数名（参数名：参数类型） -> 返回值类型{

               

    }

     如：

        func greet(person: String) -> String {
        let greeting = "Hello, " + person + "!"
        return greeting
     }

     

    greet（"wang"）

  

   func 函数名（参数名：参数类型 ，参数名：参数类型） -> 返回值类型{

               

    }

     func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
         return greetAgain(person: person)
      } else {
         return greet(person: person)
      }
   }
   print(greet( "Tim", alreadyGreeted: true))

  

   func 函数名（参数名：参数类型）{

              

   }

   没有返回值的函数，其实没有返回类型的函数会返回一个空元组（”（）“），并不是真的没有返回值

二 返回多个值
   

   func 函数名（参数名：参数类型） ->元组类型{

              

   }
   如：
       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 bounds = minMax(array: [8,-6,2, 109, 3, 71])
  print("min is \(bounds.min) and max is\(bounds.max)")
  // Prints "min is -6 and max is 109"，给元组里的返回值命名，方便取得返回值



   返回值也可以是可选的
        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)
    }
    if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
     print("min is \(bounds.min) and max is \(bounds.max)")
   }
   注意（int？，int？）和（int，int）？是不一样的，后者只是指定整个元组是可选的，如果元组不为nil那么元素必须要有返回   值。而前者元组不能为nil

三 参数标签

     

   func 函数名（参数标签  参数名：参数类型，参数标签  参数名：参数类型） ->返回值{

              

   }

   调用时：

               函数名（参数标签：参数值，参数标签：参数值）；

  

   参数标签也可以不指定，默认为参数名。

   

  我们也可以不设置参数标签

  

   

   func 函数名（_ 参数名：参数类型，_  参数名：参数类型） ->返回值{

              

   }

   用 _ 说明没有参数标签

   调用时直接   

         函数名（参数值，参数值）；

四 给参数设置默认值

   

   func 函数名（参数标签  参数名：参数类型，参数标签  参数名：参数类型 = value） ->返回值{

              

   }

    注意带默认值的参数必须放在最后，其之前的参数为不带默认值的

五 可变参的函数

   想要使某个参数接受多个值，可以直接在参数名后面加三个点（...）表示接受的参数数量可变，且只能一个这样的参数

    

    func arithmeticMean(numbers:Double...,av:Int)  {

      print(av)

      print(numbers)

   

   }

   arithmeticMean(1,2, 3,4, 5,av:5)

六 In-Out Parameters

     函数的参数默认为不可改变的，如果想改变参数值，并且想保留这种改变，可以在参数标签前加上inout

     如：

        

            

     import UIKit

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

           let temporaryA = a

           a = b

           b = temporaryA

      }

    var someInt = 3

    var anotherInt = 107

    swapTwoInts(&someInt, &anotherInt)注意穿参时要带上&

    print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

 七 函数类型

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

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

        return a + b

   }

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

        return a * b

   }

   函数类型都是（int，int）->int

1. func printHelloWorld() {
2. print("hello, world")
3. }
4. 函数类型为（）->void
5. 函数类型的用法：
6. var number ：（Int，Int）->Int = addTwoInts
7. 或者直接
   1. var number = addTwoInts
   1. number（1，2）；
   1. 函数类型用作参数

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

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

      }

      printMathResult(addTwoInts, 3, 5)

      
      

      函数类型作为返回值

      只需要把函数的返回类型该为函数类型

      func selectCal(falg:Bool) ->(Int,Int)->Int{

          return falg ? addTwoInts:multiplyTwoInts;

      }

      
      

      var cal = selectCal(true);

      cal(1,2);

      内嵌函数：

      内嵌函数是放在一个函数里面的函数，内嵌函数被他的包裹函数隐藏起来，但是其他作用域里仍然可以调用隐藏的函数，这就需要外面的函数返回了 内嵌函数；

      1. func chooseStepFunction(backward: Bool) -> (Int) -> Int {
      2. func stepForward(input: Int) -> Int { return input + 1 }
      3. func stepBackward(input: Int) -> Int { return input - 1 }
      4. return backward ? stepBackward : stepForward
      5. }
      6. var currentValue = -4
      7. let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
      8. // moveNearerToZero now refers to the nested stepForward() function
      9. while currentValue != 0 {
      10. print("\(currentValue)... ")
      11. currentValue = moveNearerToZero(currentValue)
      12. }
      13. print("zero!")
      14. // -4...
      15. // -3...
      16. // -2...
      17. // -1...
      18. // zero!