本页包含内容:
- 函数定义与调用
- 函数参数与返回值
- 函数参数标签和参数名称
- 函数类型
- 嵌套函数

** 1、函数定义与调用**
当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入，称为参数，也可以定义某种类型的值作为函数执行结束时的输出，称为返回类型。每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，用函数名来“调用”这个函数，并传给它匹配的输入值(称作实参)。函数的实参必须与函数参数表里参数的顺序一致。
下面例子中的函数的名字是 greet(person:) ，之所以叫这个名字,是因为这个函数用一个人的名字当做输入，并返回向这个人问候的语句。为了完成这个任务，你需要定义一个输入参数——一个叫做 person 的 String 值，和一个包含给这个人问候语的 String 类型的返回值:

<pre>func greet(person:String) -> String {
let greating = "Hello," + person + "!"
return greating;
}</pre>
函数调用:
<pre>let msg = greet(person: "Anna")
print(msg)
func greetAgain(person: String) -> String {
return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna"))
// 打印 "Hello again, Anna!"</pre>

2、 函数参数与返回值

• 无参数函数
  <pre> func sayHelloWorld() -> String {
  return "hello, world"
  }
  let say = sayHelloWorld()
  print(say)
  // 打印 "hello, world"</pre>

• 多参数函数(嵌套)
  <pre> func greetting(person:String, alreadyGreated: Bool) -> String {
  if alreadyGreated {
  return greetAgain(person: person)
  }else {
  return greet(person: person)
  }
  }
  let hello = greetting(person: "Tim", alreadyGreated: true)
  print(hello)
  // 打印 " Hello again, Tim! "</pre>

• 无返回值函数
  func greet1(person: String) {
  print("Hello, (person)!")
  }
  greet1(person: "Dave")
  // 打印 "Hello, Dave!"

  注:因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头"->"和返回类型。

  被调用时，一个函数的返回值可以被忽略:
  func printAndCount(string: String) -> Int {
  print(string)
  return string.characters.count
  }
  func printWithoutCounting(string: String) {
  let _ = printAndCount(string: string)
  }
  let count = printAndCount(string: "hello, world")
  print(count)
  // 打印 "hello, world" 并且返回值 12
  printWithoutCounting(string: "hello, world")
  // 打印 "hello, world" 但是没有返回任何值

• 多重返回值函数
  你可以用元组(tuple)类型让多个值作为一个复合值从函数中返回。
  下例中定义了一个名为 minMax(array:) 的函数，作用是在一个 Int 类型的数组中找出最小值与最大值。
  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)")
  // 打印 "min is -6 and max is 109"
  

• 可选元组返回类型
  // 如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的( optional ) 元组返回类型反映整个元组可以是nil的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?
  为了安全地处理这个“空数组”问题，将 minMax(array:) 函数改写为使用可选元组返回类型，并且当数组为空时返回 nil :
  <pre>func minAndMax(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)
  }

  if let bounds1 = minAndMax(array: [8, -6, 2, 109, 3, 71]) {
  print("min is (bounds1.min) and max is (bounds1.max)")
  }
  // 打印 "min is -6 and max is 109" </pre>

3、函数参数标签和参数名称

每个函数参数都有一个参数标签( argument label )以及一个参数名称( parameter name )。
参数标签在调用函数的时候使用,调用的时候需要将函数的参数标签写在对应的参数前面。
参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。

    func someFunction(firstParameterName: Int, secondParameterName: Int) {
        // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
    }
    someFunction(firstParameterName: 1, secondParameterName: 2)

所有的参数都必须有一个独一无二的名字。虽然多个参数拥有同样的参数标签是可能的，但是一个唯一的函数标签能够使你的代码更具可读性。

• 指定参数标签
  你可以在函数名称前指定它的参数标签，中间以空格分隔:

  func someFunction1(argumentLabel parameterName: Int) {
      // 在函数体内，parameterName 代表参数值
  }
  

这个版本的 greet(person:) 函数，接收一个人的名字和他的家乡，并且返回一句问候:

    func greetA(person name: String, from hometown: String) -> String {
        return "Hello \(name)!  Glad you could visit from \(hometown)."
    }
    print(greetA(person: "Bill", from: "Cupertino"))
    // 打印 "Hello Bill! Glad you could visit from Cupertino."

参数标签的使用能够让一个函数在调用时更有表达力，更类似自然语言，并且仍保持了函数内部的可读性以及清 晰的意图。

• 忽略参数标签

如果你不希望为某个参数添加一个标签，可以使用一个下划线( _ )来代替一个明确的参数标签。
<pre>func someFunction2(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction2(1, secondParameterName: 2)</pre>

注： 如果一个参数有一个标签，那么在调用的时候必须使用标签来标记这个参数。

• 默认参数值

你可以在函数体中通过给参数赋值来为任意一个参数定义默认值(Deafult Value)。当默认值被定义后，调用这 个函数时可以忽略这个参数。

    func someFunction3(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
        // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
    }
    someFunction3(parameterWithoutDefault: 3, parameterWithDefault: 6)
    // parameterWithDefault = 6
    someFunction3(parameterWithoutDefault: 4)
    // parameterWithDefault = 12

• 可变参数
  一个可变参数(variadic parameter)可以接受零个或多个值。
  函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。
  通过在变量类型名后面加入( ... )的方式来定义可变参数。

可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
下面的这个函数用来计算一组任意长度数字的算术平均数(arithmetic mean):

    func arithmeticMean(_ numbers: Double...) -> Double {
        var total: Double = 0
        for number in numbers {
            total += number
        }
        return total / Double(numbers.count)
    }
    let res1 =  arithmeticMean(1, 2, 3, 4, 5)
    print(res1)
    // 返回 3.0, 是这 5 个数的平均数。
   let res2 = arithmeticMean(3, 8.25, 18.75)
    print(res2)
    // 返回 10.0, 是这 3 个数的平均数。

注意:一个函数最多只能拥有一个可变参数。

• 输入输出参数

** 4、 函数类型**

每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
<pre> func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}</pre>
这个例子中定义了两个简单的数学函数:addTwoInts 和 multiplyTwoInts。这两个函数都接受两个 Int 值， 返回一个 Int 值
这两个函数的类型是 (Int, Int) -> Int ，可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。
下面是另一个例子，一个没有参数，也没有返回值的函数:

<pre>func printHelloWorld() {
print("hello, world")
}</pre>
这个函数的类型是: () -> Void ，或者叫“没有参数，并返回 Void 类型的函数

• 使用函数类型
  在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它:
  var mathFunction: (Int, Int) -> Int = addTwoInts
  print("Result: (mathFunction(2, 3))")
  // Prints "Result: 5"

有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样:
mathFunction = multiplyTwoInts
print("Result: (mathFunction(2, 3))")
// Prints "Result: 6"

• 函数类型作为参数类型

    func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
        print("Result: \(mathFunction(a, b))")
    }
    printMathResult(addTwoInts, 3, 5)
    // 打印 "Result: 8"
  

这个例子定义了 printMathResult(::_:) 函数，
它有三个参数:第一个参数叫 mathFunction ，类型是 (Int, Int) -> Int ，你可以传入任何这种类型的函数;
第二个和第三个参数叫 a 和 b ，它们的类型都是 Int ，这两个值作为已给出的函数的输入值。

• 函数类型作为返回类型

你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头(->)后写一个完整的函数类型。

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

如下名为 chooseStepFunction(backward:) 的函数，它的返回类型是 (Int) -> Int 类型的函数。
chooseStepF unction(backward:) 根据布尔值 backwards 来返回 stepForward(:) 函数或 stepBackward(:) 函数:

    func chooseStepFunction(backward: Bool) -> (Int) -> Int {
        return backward ? stepBackward : stepForward
    }

你现在可以用 chooseStepFunction(backward:) 来获得两个函数其中的一个:
var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 现在指向 stepBackward() 函数。

上面这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue 的初始值 是 3 ，这意味着 currentValue > 0 为真(true)，这将使得 chooseStepFunction(:) 返回 stepBackwar d(:) 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

    print("Counting to zero:")
    // Counting to zero:
    while currentValue != 0 {
        print("\(currentValue)... ")
        currentValue = moveNearerToZero(currentValue)
    }
    print("zero!")
    // 3...
    // 2...
    // 1...
    // zero!

** 5、嵌套函数**
到目前为止本章中你所见到的所有函数都叫全局函数(global functions)，它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数(nested functions)。
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数(enclosing function)调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。

你可以用返回嵌套函数的方式重写 chooseStepFunction(backward:) 函数:

    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
    }
    var currentValue = -4
    let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
    // moveNearerToZero now refers to the nested stepForward() function
    while currentValue != 0 {
        print("\(currentValue)... ")
        currentValue = moveNearerToZero(currentValue)
    }
    print("zero!")
    // -4...
    // -3...
    // -2...
    // -1...
    // zero!