函数

函数

函数就是要完成一个特定任务的一坨代码。你可以以函数的作用给一个函数命名，必要的时候这个名字就可以用来调用这个函数。
Swift的标准化函数语法足够用来表述无论是C风格的无参函数，还是复杂的OC风格的具有本地和外部参数的方法。对于简单的函数，参数可以给出默认值；还可以传递in-out参数，就是在函数执行完毕后会被修改的参数。
每个Swift的函数都有类型，类型包括了函数的参数类型和返回值类型。你可以像使用其他类型一样使用函数的类型，这样一来，函数作为参数传递给函数变得可能，同样函数作为函数的返回结果也是可以的。函数可以在 另一个函数内部定义，这样可以在嵌套函数中封装细节。

定义和调用函数

当定义一个函数，你需要定义一个或多个名字和类型，输入（参数）和输出（返回）。
每个函数都有一个名称，这个名称用来描述函数的作用。要使用一个函数，你需要按照函数的名称调用它，并且传入和函数定义类型相符的参数。传递进去的参数要和函数提供的参数列表顺序保持一致。
下面的例子中函数被叫做：sayHello，因为它的作用就是如此：它接受一个人名返回对那个人名的一个问候。为了达到这样的目的，你可以定义一个输入参数一个String类型的personName和一个String类型的返回值（包含 了对那个人的问候）：

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

所有这一切被包含在了函数定义中，函数定义有前置关键字 func。使用箭头（连字符跟一个右向的尖括号）表明函数的返回类型，紧随其后的就是函数的返回类型。
函数定义描述了函数的功能、函数可以接受的参数、函数执行完后返回什么。其作用就是方便在其他地方被调用：

println(sayHello("Anna"))
//prints "Hello,Anna!"
println(sayHello("Brian"))
//prints "Hello,Brian!"

你调用了sayHello函数通过在圆括号中传递了一个String类型的值（sayHello（”Anna”)）。因为这个函数返回一个String类型的值，所以可以被println函数包裹起来打印返回结果。
sayHello函数体内，一开始定义了一个叫做greeting的String类型常量，然后它被赋值为对personName的一个简单的问候。greeting然后被使用return关键字作为返回值返回。当return greeting被调用后，函数就结束执行返回并返回当前的greeting。
你可以用不同的参数多次调用sayHello函数。上面的例子就展示了分别使用“Anna”和“Brian”调用的情况。函数分别返回了相应的值。
为了让这个函数看起来更简洁，可以将讯息创建和返回语句组合在一行实现：

func sayHelloAgain(personName:String)->Stirng {
    return "Hello again,“+personName + "!"
}
println(sayHelloAgain("Anna"))
// prints "Hello again,Anna!"

函数的参数和返回值

Swift的函数参数以及返回值是非常灵活的。简单到只有一个无名参数的函数，复杂到有命名的参数和不同参数的选项。

多个参数

函数可以有多个参数（写在圆括号中用逗号分隔）。
下面这个函数得到一个半开区间的起始、结束索引，返回区间中的元素个数：

func​ ​halfOpenRangeLength​(​start​: ​Int​,​end​: ​Int​) -> ​Int​ {
​ ​return​ ​end​ - ​start
​}
​println​(​halfOpenRangeLength​(​1​,​10​))
​// prints "9"

没有参数

函数的参数不是必要的。下面的函数不需要参数，每次被调用都返回同样的String信息：

​func​ ​sayHelloWorld​() -> ​String​ {
​ ​return​ ​"hello,world"
​}
​println​(​sayHelloWorld​())
​// prints "hello,world"

函数定义后面仍然需要跟上圆括号，虽然没有任何参数。调用的时候需要在函数名称后面跟一对空的圆括号。

没有返回值

函数的返回值也不是必须的。这里有另外一个版本的sayHello函数叫做sayGoodbye，这个版本只是打印了内容而不是返回了内容：

​func​ ​sayGoodbye​(​personName​: ​String​) {
​ ​println​(​"Goodbye,​\(​personName​)​!"​)
​}
​sayGoodbye​(​"Dave"​)
​// prints "Goodbye,Dave!"

因为这个函数不需要返回值，所以函数定义里面没有包括箭头和返回类型。
NOTE
严格说来，sayGoodbye函数仍然返回了一个值，虽然没有任何返回值被定义。没有定义返回值的函数返回一个特殊的类型：Void。这是一个简单的空元组，也就是没有任何元素的元组，可以被写作：()

在调用时函数的返回值是可以被忽略的：

func​ ​printAndCount​(​stringToPrint​: ​String​) -> ​Int​ {
​ ​println​(​stringToPrint​)
​ ​return​ ​countElements​(​stringToPrint​)
​}
​func​ ​printWithoutCounting​(​stringToPrint​: ​String​) {
​ ​printAndCount​(​stringToPrint​)
​}
​printAndCount​(​"hello,world"​)
​// prints "hello,world" and returns a value of 12
​printWithoutCounting​(​"hello,world" but does not return a value

上例中第一个函数：printAndCount，打印了一个字符串并且将其中的字符个数作为返回值。第二个函数，printWithoutCounting，调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，信息会被打印，但是返回值被忽略了。
NOTE
尽管返回值可以被忽略，但是函数仍会按照定义返回相应的值。一个定义了返回值的函数在不允许在函数结束前仍然没有返回值，这样会造成编译时错误。

多个返回值

你可以使用元组作为函数的返回值，这样可以将多个值组合起来返回。
下面的例子定义了一个函数叫做minMax，它找到了一个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​)

minMax函数返回了一个包含两个Int数字的元组。这两个值被分别标签为：min和max，有了标签，就可以对函数的返回值做进一步的访问。
minMax函数体内，一开始开始定义了两个工作变量：currentMin和currentMax，他们初始化的值都是数组中的第一个整形数。接下来，开始遍历数组，检查数组中当前位置的值，必要的时候用合适的值替换两个工作变量的内容。最后找到的两个值被放置在一个元组中返回。
因为在函数的定义中返回元组中的内容被命名了，所以他们可以通过点号被访问：

​let​ ​bounds​ = ​minMax​([​8​,-​6​,​2​,​109​,​3​,​71​])
​println​(​"min is ​\(​bounds​.​min​)​ and max is ​\(​bounds​.​max​)​"​)
​// prints "min is -6 and max is 109"

记住：上面元组成员不需要被命名当他们作为函数的返回值返回时，因为他们的名字已经在函数的返回值定义中有了。

可选择元组返回类型

如果函数返回的元组可能没有值，那么可以使用可选元组作为返回类型，表示返回的元组可能是nil。写法就是在元组后面加问号，像这样：(Int,Int)? 或者 (String,Int,Bool)?。

上面minMax函数返回了一个包含两个Int的元组。但是它没有对输入的参数数组做任何安全检查。如果输入的数组是空的，那么访问它的第一个元素array[0]，就会造成运行时错误。
为了解决这个问题，在数组为空时返回nil就可以了：

func​ ​minMax​(​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​)

你可以使用选择绑定判断这个版本的minMax函数的返回值是有效值还是nil：
​

if​ ​let​ ​bounds​ = ​minMax​([​8​,​71​]) {
​ ​println​(​"min is ​\(​bounds​.​min​)​ and max is ​\(​bounds​.​max​)​"​)
​}
​// prints "min is -6 and max is 109"

函数参数名称

所有上面的函数定义了他们的参数在参数列表中：

func​ ​someFunction​(​parameterName​: ​Int​) {
​ ​// function body goes here,and can use parameterName
​ ​// to refer to the argument value for that parameter
​}

然而，这些参数名称只能在函数的函数体内使用，在调用函数时不能使用。这类的参数被称为局部参数名称（ local parameter names），因为他们只在函数体内有效。

外部参数名称

给参数分别起名字表示参数各自的含义这是件非常有意义 事，在调用函数的时候。
如果你想让你的函数使用者在调用函数时使用参数的名称，你可以在函数定义时在局部参数名称之前使用采用外部参数名称。外部参数名称写在局部参数名称之前，用空格将两者区分开来：

​func​ ​someFunction​(​externalParameterName​ ​localParameterName​: ​Int​) {
​ ​// function body goes here,and can use localParameterName
​ ​// to refer to the argument value for that parameter
​}

NOTE
如果你在定义中使用了外部参数名称，那么在调用时总要使用外部参数名称。
下面的例子使用一个连接符号将两个字符串连接起来：

func​ ​join​(​s1​: ​String​,​s2​: ​String​,​joiner​: ​String​) -> ​String​ {
​ ​return​ ​s1​ + ​joiner​ + ​s2
​}

在你调用这个函数的时候，三个字符串类型的参数的含义是不明晰的：

join​(​"hello"​,​"world"​,​","​)
​// returns "hello,world"

为了明确表示三个参数的含义，给join函数的每个参数添加外部参数名称：

​func​ ​join​(​string​ ​s1​: ​String​,​toString​ ​s2​: ​String​,​withJoiner​ ​joiner​: ​String​)
​ -> ​String​ {
​ ​return​ ​s1​ + ​joiner​ + ​s2
​}

在这个版本的join函数中，第一个参数有一个外部名字：string 和一个局部名字s1，第二个参数有一个外部名字toString和一个局部名字s2，第三个参数有一个外部名字withJoiner 和一个局部名字 joiner。

现在你可以使用外部名字明确的调用函数了：

join​(​string​: ​"hello"​,​toString​: ​"world"​,​withJoiner​: ​",world"

采用了外部参数名称，使得第二个版本的join函数在调用的时候很明晰。
NOTE
当你的函数在被别人调用时，参数的含义不明晰的时候，你就要考虑使用外部参数名了。如果你的函数目的很明晰了，就不必使用外部参数名。

简写外部参数名称

如果你要给参数使用外部名称，同时你的局部参数名称就能够表示参数的含义了，这时你不必写两次同样的名称分别表示它们了。写那个名字一次，在它的前面加上井号就可以，这个告诉Swift这个参数的局部名称和外部名称相同。
下面的例子定义了一个叫做containsCharacter，其中在局部参数名称之前使用了井号定义了参数的外部名称：
​

func​ ​containsCharacter​(#​string​: ​String​,#​characterToFind​: ​Character​) -> ​Bool​ {
​ ​for​ ​character​ ​in​ ​string​ {
​ ​if​ ​character​ == ​characterToFind​ {
​ ​return​ ​true
​ }
​ }
​ ​return​ ​false
​}

是不是好多了：

let​ ​containsAVee​ = ​containsCharacter​(​string​: ​"aardvark"​,​characterToFind​: ​"v"​)
​// containsAVee equals true,because "aardvark" contains a "v"

question：
可以一部分使用外部名称，另一部分不使用吗？

默认的参数值

可以在函数定义到时候给参数定义默认值。如果参数有了默认值，调用函数的时候可以将其省略。
NOTE
需要将有默认值的参数放在函数的参数列表末尾。这样做的目的是为了保证函数的所有调用都有相同的非默认参数列表顺序，也为了调用时能够明晰。
这里提供了上面join函数的另一个版本，给出了joiner的默认值：
​

func​ ​join​(​string​ ​s1​: ​String​,​ ​withJoiner​ ​joiner​: ​String​ = ​" "​) -> ​String​ {
​ ​return​ ​s1​ + ​joiner​ + ​s2
​}

如果在调用时joiner被传入了一个字符串，这个字符串将和上一个版本中一样将其他两个字符串连接起来：

join​(​string​: ​"hello"​,​withJoiner​: ​"-"​)
​// returns "hello-world"

然而，如果没有字符串传给joiner，那么默认值“ ”将会派上用场：
​

join​(​string​: ​"hello"​,​toString​: ​"world"​)
​// returns "hello world"

有默认值的外部参数名称

给有外部参数名称的参数提供默认值也是必须的。同样是为了保证函数被调用的时候更便于理解。
为了简化，Swift给有默认值的参数提供了自动的 外部参数名称。自动的外部参数名称和它的局部参数名称相同，就像你在局部参数名称之前用了井号一样。
这里是join函数的另一个版本，不再使用外部名称，但是给joiner提供了默认值：

​func​ ​join​(​s1​: ​String​,​joiner​: ​String​ = ​" "​) -> ​String​ {
​ ​return​ ​s1​ + ​joiner​ + ​s2
​}

这个例子中Swift给joiner提供了一个外部参数名称（和局部参数名称一致）。为了让有默认值的参数在调用时目的明确，必须使用它的外部参数名称。

join​(​"hello"​,​joiner​: ​"-"​)
​// returns "hello-world"

NOTE

可变参数（Variadic Parameters）

可变参数可以接受0个或多个特定类型的值。使用可变参数指定在调用时可以传递不定个数的参数。定义可变参数的方式就是在参数类型后面跟上三个点号。
传递给可变参数的值在函数体内作为特定类型（可变参数的类型）的数组使用。比如一个叫做numbers的可变参数是Doublel类型的，在函数体内可以当作名称为nubmers的[Double]类型数组常量使用。
下面的例子计算任意个数字的平均值：
​

func​ ​arithmeticMean​(​numbers​: ​Double​...) -> ​Double​ {
​ ​var​ ​total​: ​Double​ = ​0
​ ​for​ ​number​ ​in​ ​numbers​ {
​ ​total​ += ​number
​ }
​ ​return​ ​total​ / ​Double​(​numbers​.​count​)
​}
​arithmeticMean​(​1​,​4​,​5​)
​// returns 3.0,which is the arithmetic mean of these five numbers
​arithmeticMean​(​3​,​8.25​,​18.75​)
​// returns 10.0,which is the arithmetic mean of these three numbers

NOTE
一个函数最多只能有一个可变参数，而且只能放在参数列表的最后，这样为了避免调用时混乱。
如果你的函数有一个或多个参数有默认值，同时也有一个可变参数，那么将可变参数放置在参数列表的最后。

不可修改参数和可修改参数

函数的参数默认是常量。试图在函数体内修改参数的值，将会返回一个编译时错误。这就意味着你不能修改参数的值。
然而，有时函数需要份可以修改的参数副本。你可以避免在函数体内定义一个或多个新的变量，使用可修改参数（variable parameters）就好了。可修改参数提供了一个可以修改的副本供你在函数体内使用。
定义一个可修改参数就是在参数名称前添加关键字：var：

func​ ​alignRight​(​var​ ​string​: ​String​,​count​: ​Int​,​pad​: ​Character​) -> ​String​ {
​ ​let​ ​amountToPad​ = ​count​ - ​countElements​(​string​)
​ ​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​,​10​,​"-"​)
​// paddedString is equal to "-----hello"
​// originalString is still equal to "hello"

这个例子定义了一个新函数叫做alignRight，它的作用是按照一个长度向右对其文本。左侧的空白区域会被一个特殊的填充字符占据。这个例子中，字符串“hello”被转换成了字符串“——hello”。
alignRight函数定义了输入参数string为可修改参数。这就意味着，string成为了一个合法的局部变量，而且初始化的值就是参数传递来的值，进而可以在函数体内被操做。
函数的开始，计算了string左侧需要多少个填充字符。这个计算结果被保存在一个叫做amountToPad上面。如果不需要填充（这意味着amountToPad的值小于1），函数就直接返回string而不需要填充。
另外，韩苏创建了一个临时的String类型的常量，叫做padString，用初始化pad字符对其进行了初始化。添加了amuntToPad个padString的副本到了string的左侧。（字符串不能添加到一个字符之上，所以padString常量用来确保+操作的两个操作值都是Stirng类型的）
NOTE
可修改参数的变化在函数被调用之后就不起作用了，同样在函数外部不可见。可修改参数只存在于函数调用的生命周期。

In-Out参数

上述的可修改参数，只能在函数体内被修改。如果你想让一个函数能够修改参数，并且在函数执行完后保持这个修改，那么定义一个in-out参数吧。
定义一个in-out参数的方式实在参数定义之前加上inout关键字。一个in-out参数接收传递到函数的参数值，这个值被修改，修改后的值会取代原来的值。
采用in-out参数，你只可以使用变量。不能传递常量或者字面值，因为二者不能被修改。你可以在变量前使用&记号，当你要将它作为in-out参数传递给函数时，意思就是他可以被函数修改。（调用时参数名前加&标记）
NOTE
in-out参数不可以有默认值，可变参数也不可以使用inout关键字。如果你使用了inout，就不能再使用var或者let 关键字标记同一个参数了。
这里有一个叫做swapTwoInts的函数，它有两个in-out参数叫做a和b：

func​ ​swapTwoInts​(​inout​ ​a​: ​Int​,​inout​ ​b​: ​Int​) {
​ ​let​ ​temporaryA​ = ​a
​ ​a​ = ​b
​ ​b​ = ​temporaryA
​}

这个函数将两个in-out参数的值做了交换。其间使用了常量temporaryA做中转。
你可以用两个Int数值调用swapTwoInts函数。注意在调用时someInt和anotherInt这两个参数名之前，使用了&：
​

var​ ​someInt​ = ​3
​var​ ​anotherInt​ = ​107
​swapTwoInts​(&​someInt​,&​anotherInt​)
​println​(​"someInt is now ​\(​someInt​)​,and anotherInt is now ​\(​anotherInt​)​"​)
​// prints "someInt is now 107,and anotherInt is now 3"

上面显示someInt和anotherInt的初始值被swapTwoInts函数修改了，尽管这两个变量在函数外定义。
NOTE
in-out参数和函数的返回值不同。上面swapTwoInts的函数，没有定义函数的返回值，但是函数仍然做到了修改两个变量值的目的。使用in-out参数是在一种影响函数定义之外变量的选择。

函数类型

每个函数都有特定的函数类型，由参数的类型和返回值的类型决定。
举例：
​

func​ ​addTwoInts​(​a​: ​Int​,​b​: ​Int​) -> ​Int​ {
​ ​return​ ​a​ + ​b
​}
​func​ ​multiplyTwoInts​(​a​: ​Int​,​b​: ​Int​) -> ​Int​ {
​ ​return​ ​a​ * ​b
​}

这个例子定义了两个简单的数学计算函数，分别叫做addTwoInts和multiplyTwoInts。这个函数有两个Int参数，一个Int类型的返回值（数学计算的结果）。
这两个函数都是(Int,Int) -> Int类型的。可以被解读为：
“一个有两个Int类型的参数和一个Int类型返回值的函数”。
这里有另一例子，没有任何参数也没有返回值：

func​ ​printHelloWorld​() {
​ ​println​(​"hello,world"​)
​}

这个函数的类型是：() -> ()，或者“一个没有参数返回Void的函数类型”。函数没有明确返回值的情况都返回Void，在Swift中其实是返回一个空的元组，显示为()。

使用函数类型

函数类型是Swift语言中的另一种类型。举例说明，你可以定义一个函数类型的常量或者变量，然后给其赋值：

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

这行代码可以这样解读：
“定义了一个有两个Int参数返回值是一个Int的函数类型变量，然后将一个叫做addTwoInts的变量赋值给它。”
addTwoInts函数和mathFunction变量具有的相同的类型，所以可以通过Swift的类型检查。
你可以调用那个函数，通过使用mathFunction这个名字：
​

println​(​"Result: ​\(​mathFunction​(​2​,​3​))​"​)
​// prints "Result: 5"

同理，相同的函数类型函数都可以赋值给那个变量：

​mathFunction​ = ​multiplyTwoInts
​println​(​"Result: ​\(​mathFunction​(​2​,​3​))​"​)
​// prints "Result: 6"

和其他类型一样，进行赋值时，你可以让Swift自己去猜测常量和变量的类型：

let​ ​anotherMathFunction​ = ​addTwoInts
​// anotherMathFunction is inferred to be of type (Int,Int) -> Int

（尽管没有定义anotherMathFunction的类型，但赋值内容已经有了足够多的信息了）

函数类型作为参数

你可以把一个函数类型（比如(Int,Int) -> Int）作为另一个函数的参数类型。这样做，在函数被调用时让函数的调用者可以提供函数的具体表现。
这里是一个一打印上面数学函数结果的例子：

​func​ ​printMathResult​(​mathFunction​: (​Int​,​Int​) -> ​Int​,​a​: ​Int​,​b​: ​Int​) {
​ ​println​(​"Result: ​\(​mathFunction​(​a​,​b​))​"​)
​}
​printMathResult​(​addTwoInts​,​5​)
​// prints "Result: 8"

这个例子定义了一个函数叫做printMathResult 的函数，它有三个参数。第一个参数叫做mathFunction是一个(Int,Int) -> Int的函数类型。你可以传递任何符合该类型的函数作为第一个参数。第二和第三个参数分别被叫做a和b，他们都是Int类型的。他俩作为传入的数学函数的参数使用。
当printMathResult 函数被调用，它被传入了addTwoInts 函数，和两个整形值3和5.函数体内，作为参数传入的数学函数被传入3和5调用，结果8被打印出来。
printMathResult 起到的角色是：调用一个数学函数并将其结果打印出来。它不必关心具体执行的函数细节，他只关心执行函数的类型是正确的就可以了。通过类型安全，使得printMathResult 能够将实现细节丢给函数的调用者去处理。

函数作为返回类型

你可以使用函数类型作为另一个函数的返回类型。这样做需要在定义函数的时候在->后面书写完整的函数定义。
接下来的例子定义了两个简单的函数分别叫做setForward和setpBackward。setpForward函数返回调用参数值机加1的数值，setpBackward函数返回调用参数值减1的数值。他们两个的类型都是(Int) -> Int：

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

这里有一个函数叫做chooseStepFunction，它返回一个函数类型：(Int) -> Int。chooseStepFunction 返回函数stepForward 或者stepBackward，依据是一个布尔类型的变量backwards：
​

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

现在你可以使用chooseStepFunction 来获得一个（自增或自减的）函数：

var​ ​currentValue​ = ​3
​let​ ​moveNearerToZero​ = ​chooseStepFunction​(​currentValue​ > ​0​)
​// moveNearerToZero now refers to the stepBackward() function

前述的例子根据变量currentValue 来得到​moveNearerToZero​ 常量的值（一个正向或负向改变值趋于0的函数）。
限制moveNearerToZero 的值是正确的函数了，它被用来计数，直到0：
​

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

嵌套函数

本章中你遇到的所有函数都是全局函数（global functions），他们被定义在全局域中。同样你可以在函数内部定义另一个函数（这就是嵌套函数）。
默认情况下，匿名函数对于外面的世界是隐身的，当时让它仍能够被它的闭包函数调用。闭包函数可以将匿名函数返回，使得匿名函数可以在另一个作用域内被调用。
你可以重写chooseStepFunction 函数的例子，通过使用和返回一个匿名方法：

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