函數(shù)是執(zhí)行特定任務(wù)的代碼自包含塊。給定一個函數(shù)名稱標(biāo)識, 當(dāng)執(zhí)行其任務(wù)時就可以用這個標(biāo)識來進(jìn)行”調(diào)用”。
Swift的統(tǒng)一的功能語法足夠靈活來表達(dá)任何東西，無論是甚至沒有參數(shù)名稱的簡單的C風(fēng)格的函數(shù)表達(dá)式，還是需要為每個本地參數(shù)和外部參數(shù)設(shè)置復(fù)雜名稱的Objective-C語言風(fēng)格的函數(shù)。參數(shù)提供默認(rèn)值，以簡化函數(shù)調(diào)用，并通過設(shè)置在輸入輸出參數(shù)，在函數(shù)執(zhí)行完成時修改傳遞的變量。
Swift中的每個函數(shù)都有一個類型，包括函數(shù)的參數(shù)類型和返回類型。您可以方便的使用此類型像任何其他類型一樣,這使得它很容易將函數(shù)作為參數(shù)傳遞給其他函數(shù),甚至從函數(shù)中返回函數(shù)類型。函數(shù)也可以寫在其他函數(shù)中來封裝一個嵌套函數(shù)用以范圍內(nèi)有用的功能。
1、函數(shù)的聲明與調(diào)用
當(dāng)你定義一個函數(shù)時，你可以為其定義一個或多個不同名稱、類型值作為函數(shù)的輸入（稱為參數(shù)），當(dāng)該函數(shù)完成時將傳回輸出定義的類型（稱為作為它的返回類型）。
每一個函數(shù)都有一個函數(shù)名，用來描述了函數(shù)執(zhí)行的任務(wù)。要使用一個函數(shù)的功能時，你通過使用它的名稱進(jìn)行“調(diào)用”，并通過它的輸入值（稱為參數(shù)）來匹配函數(shù)的參數(shù)類型。一個函數(shù)的提供的參數(shù)必須始終以相同的順序來作為函數(shù)參數(shù)列表。
例如在下面的例子中被調(diào)用的函數(shù)greetingForPerson，像它描述的那樣 — 它需要一個人的名字作為輸入并返回一句問候給那個人。
func sayHello(personName: String) -> String {
let greeting = "Hello, " + personName + "!"
return greeting
}
所有這些信息都匯總到函數(shù)的定義中，并以func關(guān)鍵字為前綴。您指定的函數(shù)的返回類型是以箭頭->（一個連字符后跟一個右尖括號）以及隨后類型的名稱作為返回的。
該定義描述了函數(shù)的作用是什么，它期望接收什么，以及當(dāng)它完成返回的結(jié)果是什么。該定義很容易讓該函數(shù)可以讓你在代碼的其他地方以清晰、明確的方式來調(diào)用：
println(sayHello("Anna"))
// prints "Hello, Anna!"
println(sayHello("Brian"))
// prints "Hello, Brian!"
通過括號內(nèi)String類型參數(shù)值調(diào)用sayHello的函數(shù)，如的sayHello（”Anna”）。由于該函數(shù)返回一個字符串值，sayHello的可以被包裹在一個println函數(shù)調(diào)用中來打印字符串，看看它的返回值，如上圖所示。
在sayHello的函數(shù)體開始定義了一個新的名為greeting的String常量，并將其設(shè)置加上personName個人姓名組成一句簡單的問候消息。然后這個問候函數(shù)以關(guān)鍵字return來傳回。只要問候函數(shù)被調(diào)用時，函數(shù)執(zhí)行完畢是就會返回問候語的當(dāng)前值。
你可以通過不同的輸入值多次調(diào)用sayHello的函數(shù)。上面的例子顯示了如果它以”Anna”為輸入值，以”Brian”為輸入值會發(fā)生什么。函數(shù)的返回在每種情況下都是量身定制的問候。
為了簡化這個函數(shù)的主體，結(jié)合消息創(chuàng)建和return語句用一行來表示：
func sayHello(personName: String) -> String {
return "Hello again, " + personName + "!"
}
println(sayHello("Anna"))
// prints "Hello again, Anna!"
2、函數(shù)的參數(shù)和返回值
在swift中函數(shù)的參數(shù)和返回值是非常具有靈活性的。你可以定義任何東西無論是一個簡單的僅僅有一個未命名的參數(shù)的函數(shù)還是那種具有豐富的參數(shù)名稱和不同的參數(shù)選項(xiàng)的復(fù)雜函數(shù)。
多輸入?yún)?shù)
函數(shù)可以有多個輸入?yún)?shù)，把他們寫到函數(shù)的括號內(nèi)，并用逗號加以分隔。下面這個函數(shù)設(shè)置了一個開始和結(jié)束索引的一個半開區(qū)間，用來計算在范圍內(nèi)有多少元素包含：
func halfOpenRangeLength(start: Int, end: Int) -> Int {
return end - start
}
println(halfOpenRangeLength(1, 10))
// prints "9"
無參函數(shù)
函數(shù)并沒有要求一定要定義的輸入?yún)?shù)。下面就一個沒有輸入?yún)?shù)的函數(shù)，任何時候調(diào)用時它總是返回相同的字符串消息：
func sayHelloWorld() -> String {
return "hello, world"
}
println(sayHelloWorld())
// prints "hello, world"
該函數(shù)的定義在函數(shù)的名稱后還需要括號，即使它不帶任何參數(shù)。當(dāng)函數(shù)被調(diào)用時函數(shù)名稱也要跟著一對空括號。
沒有返回值的函數(shù)
函數(shù)也不需要定義一個返回類型。這里有一個版本的sayHello的函數(shù)，稱為waveGoodbye，它會輸出自己的字符串值而不是函數(shù)返回：
func sayGoodbye(personName: String) {
println("Goodbye, /(personName)!")
}
sayGoodbye("Dave")
// prints "Goodbye, Dave!"
因?yàn)樗⒉恍枰祷匾粋€值，該函數(shù)的定義不包括返回箭頭（ – >）和返回類型。
提示
嚴(yán)格地說，sayGoodbye功能確實(shí)還返回一個值，即使沒有返回值定義。函數(shù)沒有定義返回類型但返
回了一個void返回類型的特殊值。它是一個簡直是空的元組，實(shí)際上零個元素的元組，可以寫為（）。
當(dāng)一個函數(shù)調(diào)用時它的返回值可以忽略不計：
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")
// prints "hello, world" but does not return a value
第一個函數(shù)printAndCount，打印了一個字符串，然后并以Int類型返回它的字符數(shù)。第二個函數(shù)printWithoutCounting，調(diào)用的第一個函數(shù)，但忽略它的返回值。當(dāng)?shù)诙瘮?shù)被調(diào)用時，字符串消息由第一函數(shù)打印了回來，去沒有使用其返回值。
提示
返回值可以忽略不計，但對一個函數(shù)來說，它的返回值即便不使用還是一定會返回的。在函數(shù)體底部
返回時與定義的返回類型的函數(shù)不能相容時，如果試圖這樣做將導(dǎo)致一個編譯時錯誤。
多返回值函數(shù)
你可以使用一個元組類型作為函數(shù)的返回類型返回一個有多個值組成的一個復(fù)合作為返回值。
下面的例子定義了一個名為count函數(shù)，用它計來算字符串中基于標(biāo)準(zhǔn)的美式英語中設(shè)定使用的元音、輔音以及字符的數(shù)量：
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
for character in string {
switch String(character).lowercaseString {
case "a", "e", "i", "o", "u":
++vowels
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
++consonants
default:
++others
}
}
return (vowels, consonants, others)
}
您可以使用此計數(shù)函數(shù)來對任意字符串進(jìn)行字符計數(shù)，并檢索統(tǒng)計總數(shù)的元組三個指定Int值：
let total = count("some arbitrary string!")
println("/(total.vowels) vowels and /(total.consonants) consonants")
// prints "6 vowels and 13 consonants"
需要注意的是在這一點(diǎn)上元組的成員不需要被命名在該該函數(shù)返回的元組中，因?yàn)樗麄兊拿忠呀?jīng)被指定為函數(shù)的返回類型的一部分。
3、函數(shù)參數(shù)名
所有上面的函數(shù)都為參數(shù)定義了參數(shù)名稱：
func someFunction(parameterName: Int) {
// function body goes here, and can use parameterName
// to refer to the argument value for that parameter
}
然而，這些參數(shù)名的僅能在函數(shù)本身的主體內(nèi)使用，在調(diào)用函數(shù)時，不能使用。這些類型的參數(shù)名稱被稱為本地的參數(shù)，因?yàn)樗鼈冎贿m用于函數(shù)體中使用。
外部參數(shù)名
有時當(dāng)你調(diào)用一個函數(shù)將每個參數(shù)進(jìn)行命名是非常有用的，以表明你傳遞給函數(shù)的每個參數(shù)的目的。
如果你希望用戶函數(shù)調(diào)用你的函數(shù)時提供參數(shù)名稱,除了設(shè)置本地地的參數(shù)名稱，也要為每個參數(shù)定義外部參數(shù)名稱。你寫一個外部參數(shù)名稱在它所支持的本地參數(shù)名稱之前,之間用一個空格來分隔:
func someFunction(externalParameterName localParameterName: Int) {
// function body goes here, and can use localParameterName
// to refer to the argument value for that parameter
}
注意
如果您為參數(shù)提供一個外部參數(shù)名稱，調(diào)用該函數(shù)時外部名稱必須始終被使用。
作為一個例子，考慮下面的函數(shù)，它通過插入他們之間的第三個”joiner”字符串來連接兩個字符串：
func join(s1: String, s2: String, joiner: String) -> String {
return s1 + joiner + s2
}
當(dāng)你調(diào)用這個函數(shù)，你傳遞給函數(shù)的三個字符串的目的就不是很清楚了：
join("hello", "world", ", ")
// returns "hello, world"
為了使這些字符串值的目的更為清晰,為每個join函數(shù)參數(shù)定義外部參數(shù)名稱:
func join(string s1: String, toString s2: String, withJoiner joiner: String)
-> String {
return s1 + joiner + s2
}
在這個版本的join函數(shù)中，第一個參數(shù)有一個外部名稱string和一個本地名稱s1;第二個參數(shù)有一個外部名稱toString和一個本地名稱s2;第三個參數(shù)有一個外部名稱withJoiner和一個本地名稱joiner。
現(xiàn)在，您可以使用這些外部參數(shù)名稱調(diào)用清楚明確的調(diào)用該函數(shù)：
join(string: "hello", toString: "world", withJoiner: ", ")
// returns "hello, world"
使用外部參數(shù)名稱使join函數(shù)的第二個版本功能更富有表現(xiàn)力,用戶習(xí)慣使用sentence-like的方式,同時還提供了一個可讀的、意圖明確的函數(shù)體。
注意
考慮到使用外部參數(shù)名稱的初衷就是為了在別人第一次閱讀你的代碼時并不知道你函數(shù)參數(shù)的目的是什么。
但當(dāng)函數(shù)調(diào)用時如果每個參數(shù)的目的是明確的和毫不含糊的，你并不需要指定外部參數(shù)名稱。
外部參數(shù)名稱速記
如果你想為一個函數(shù)參數(shù)提供一個外部參數(shù)名，然而本地參數(shù)名已經(jīng)使用了一個合適的名稱了，你不需要為該參數(shù)寫相同的兩次名稱。取而代之的是，寫一次名字，并用一個hash符號（＃）作為名稱的前綴。這告訴Swift使用該名稱同時作為本地參數(shù)名稱和外部參數(shù)名稱。
這個例子定義了一個名為containsCharacter的函數(shù),定義了兩個參數(shù)的外部參數(shù)名稱并通過放置一個散列標(biāo)志在他們本地參數(shù)名稱之前:
func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
for character in string {
if character == characterToFind {
return true
}
}
return false
}
這個函數(shù)選擇的參數(shù)名稱清晰的、函數(shù)體極具可讀性,使的該函數(shù)被調(diào)用時沒有歧義:
let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
// containsAVee equals true, because "aardvark" contains a "v"
參數(shù)的默認(rèn)值
可以為任何參數(shù)設(shè)定默認(rèn)值來作為函數(shù)的定義的一部分。如果默認(rèn)值已經(jīng)定義，調(diào)用函數(shù)時就可以省略該參數(shù)的傳值。
注意
將使用默認(rèn)值的參數(shù)放在函數(shù)的參數(shù)列表的末尾。這確保了所有調(diào)用函數(shù)的非默認(rèn)參數(shù)使用相同的順
序,并明確地表示在每種情況下相同的函數(shù)調(diào)用。
這里有一個版本，是早期的join函數(shù)，并為參數(shù)joiner設(shè)置了默認(rèn)值：
func join(string s1: String, toString s2: String,
withJoiner joiner: String = " ") -> String {
return s1 + joiner + s2
}
如果在join函數(shù)被調(diào)用時提供給joiner一個字符串值，該字符串是用來連接兩個字符串，就跟以前一樣：
join(string: "hello", toString: "world", withJoiner: "-")
// returns "hello-world"
但是，如果當(dāng)函數(shù)被調(diào)用時提供了joiner的沒有值，就會使用單個空格（” “）的默認(rèn)值：
join(string: "hello", toString: "world")
// returns "hello world"
有默認(rèn)值的外部名稱參數(shù)
在大多數(shù)情況下,為所有參數(shù)提供一個外部帶有默認(rèn)值的參數(shù)的名稱是非常有用的(因此要求)。這將確如果當(dāng)函數(shù)被調(diào)用時提供的值時參數(shù)必須具有明確的目的。
為了使這個過程更容易，當(dāng)你自己沒有提供外部名稱時，Swift自動為所有參數(shù)定義了缺省的參數(shù)外部名稱。自動外部名稱與本地名稱相同，就好像你在你的代碼中的本地名稱之前寫了一個hash符號。
這里有一個早期join函數(shù)版本，它不為任何參數(shù)提供的外部名稱，但仍然提供了joiner參數(shù)的默認(rèn)值：
func join(s1: String, s2: String, joiner: String = " ") -> String {
return s1 + joiner + s2
}
在這種情況下，Swift自動為一個具有默認(rèn)值的參數(shù)提供了外部參數(shù)名稱。調(diào)用函數(shù)時，為使得參數(shù)的目的明確、毫不含糊，因此必須提供外部名稱：
join("hello", "world", joiner: "-")
// returns "hello-world"
注意
你可以通過編寫一個下劃線(_)有選擇進(jìn)行這種行為,而不是一個明確的定義外部參數(shù)名稱。然
而，在適當(dāng)情況下有默認(rèn)值的外部名稱參數(shù)總是優(yōu)先被使用。
可變參數(shù)
一個可變參數(shù)的參數(shù)接受零個或多個指定類型的值。當(dāng)函數(shù)被調(diào)用時，您可以使用一個可變參數(shù)的參數(shù)來指定該參數(shù)可以傳遞不同數(shù)量的輸入值。寫可變參數(shù)的參數(shù)時，需要參數(shù)的類型名稱后加上點(diǎn)字符（…）。
傳遞一個可變參數(shù)的參數(shù)的值時，函數(shù)體中是以提供適當(dāng)類型的數(shù)組的形式存在。例如,一個可變參數(shù)的名稱為numbers和類型為Double…在函數(shù)體內(nèi)就作為名為numbers類型為Double[]的常量數(shù)組。
下面的示例計算任意長度的數(shù)字的算術(shù)平均值（也稱為平均）：
func arithmeticMean(numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8, 19)
// returns 10.0, which is the arithmetic mean of these three numbers
注意
函數(shù)可以最多有一個可變參數(shù)的參數(shù)，而且它必須出現(xiàn)在參數(shù)列表的最后以避免多參數(shù)函
數(shù)調(diào)用時出現(xiàn)歧義。
如果函數(shù)有一個或多個參數(shù)使用默認(rèn)值，并且還具有可變參數(shù)，將可變參數(shù)放在列表的
最末尾的所有默認(rèn)值的參數(shù)之后。
常量參數(shù)和變量參數(shù)
函數(shù)參數(shù)的默認(rèn)值都是常量。試圖改變一個函數(shù)參數(shù)的值會讓這個函數(shù)體內(nèi)部產(chǎn)生一個編譯時錯誤。這意味著您不能錯誤地改變參數(shù)的值。
但是，有時函數(shù)有一個參數(shù)的值的變量副本是非常有用的。您可以通過指定一個或多個參數(shù)作為變量參數(shù)，而不是避免在函數(shù)內(nèi)部為自己定義一個新的變量。變量參數(shù)可以是變量而不是常量,并給函數(shù)中新修改的參數(shù)的值的提供一個副本。
在參數(shù)名稱前用關(guān)鍵字var定義變量參數(shù)：
func alignRight(var string: String, count: Int, pad: Character) -> String {
let amountToPad = count - countElements(string)
for _ in 1...amountToPad {
string = pad + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, 10, "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"
這個例子定義了一個新函數(shù)叫做alignRight,它對準(zhǔn)一個輸入字符串，以一個較長的輸出字符串。在左側(cè)的空間中填充規(guī)定的字符。在該示例中，字符串”hello”被轉(zhuǎn)換為字符串”—–hello”。
該alignRight函數(shù)把輸入?yún)?shù)的字符串定義成了一個變量參數(shù)。這意味著字符串現(xiàn)在可以作為一個局部變量，用傳入的字符串值初始化，并且可以在函數(shù)體中進(jìn)行相應(yīng)操作。
函數(shù)首先找出有多少字符需要被添加到左邊讓字符串以右對齊在整個字符串中。這個值存儲在本地常量amountToPad中。該函數(shù)然后將填充字符的amountToPad個字符拷貝到現(xiàn)有的字符串的左邊，并返回結(jié)果。整個過程使用字符串變量參數(shù)進(jìn)行字符串操作。
注意
一個變量參數(shù)的變化沒有超出了每個調(diào)用函數(shù),所以對外部函數(shù)體是不可見的。變量參數(shù)只能存在于函數(shù)調(diào)用
的生命周期里。
輸入-輸出參數(shù)
可變參數(shù)，如上所述，只能在函數(shù)本身內(nèi)改變。如果你想有一個函數(shù)來修改參數(shù)的值，并且想讓這些變化要堅(jiān)持在函數(shù)調(diào)用結(jié)束后，你就可以定義輸入-輸出參數(shù)來代替。
通過在其參數(shù)定義的開始添加inout關(guān)鍵字寫用來標(biāo)明輸入-輸出參數(shù)。一個在輸入-輸出參數(shù)都有一個傳遞給函數(shù)的值，由函數(shù)修改后，并從函數(shù)返回來替換原來的值。
4、函數(shù)類型
每個函數(shù)都有一個特定的類型，包括參數(shù)類型和返回值類型，比如：
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int {
return a * b
}
這個例子定義了兩個簡單的數(shù)學(xué)函數(shù)addTwoInts和multiplyTwoInts。每個函數(shù)接受兩個int參數(shù)，返回一個int值，執(zhí)行相應(yīng)的數(shù)學(xué)運(yùn)算然后返回結(jié)果
這兩個函數(shù)的類型是(Int, Int)->Int可以解釋為：
這個函數(shù)類型它有兩個int型的參數(shù)，并返回一個int類型的值
下面這個例子是一個不帶任何參數(shù)和返回值的函數(shù)：
func printHelloWorld() {
println("hello, world")
}
這個函數(shù)的類型是()->()，或者函數(shù)沒有參數(shù)，返回void。函數(shù)沒有顯式地指定返回類型，默認(rèn)為void，在Swift中相當(dāng)于一個空元組，記為()。
使用函數(shù)類型
在swift中你可以像任何其他類型一樣的使用函數(shù)類型。例如，你可以定義一個常量或變量為一個函數(shù)類型，并指定適當(dāng)?shù)暮瘮?shù)給該變量：
var mathFunction: (Int, Int) -> Int = addTwoInts
可以解讀為：
“定義一個名為mathFunction變量，該變量的類型為'一個函數(shù)，它接受兩個int值，并返回一個int值。'設(shè)置這個新的變量來引用名為addTwoInts函數(shù)的功能。”
該mathFunction函數(shù)具有與addTwoInts函數(shù)相同類型的變量，所以這個賦值能通過Swift的類型檢查。
現(xiàn)在你可以調(diào)用指定的函數(shù)名稱為mathFunction：
println("Result: /(mathFunction(2, 3))")
// prints "Result: 5"
不同的函數(shù)相同的匹配類型可以分配給相同的變量,也同樣的適用于非函數(shù)性類型:
mathFunction = multiplyTwoInts
println("Result: /(mathFunction(2, 3))")
// prints "Result: 6"
與其他類型一樣,你可以把它迅速定義成函數(shù)類型當(dāng)你為常量或變量分配一個函數(shù)時:
let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int
函數(shù)類型的參數(shù)
可以使用一個函數(shù)類型，如(Int, Int)->Int作為另一個函數(shù)的參數(shù)類型。這使你預(yù)留了一個函數(shù)的某些方面的實(shí)現(xiàn)，讓調(diào)用者調(diào)用函數(shù)時提供。
下面就以打印上面的數(shù)學(xué)函數(shù)的結(jié)果為例：
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
println("Result: /(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"
這個例子中定義了一個名為printMathResult函數(shù)，它有三個參數(shù)。第一個參數(shù)名為mathFunction，類型為(Int, Int)->Int。您可以傳入符合條件的任何函數(shù)類型作為此函數(shù)的第一個參數(shù)。第二和第三個參數(shù)a、b都是int類型。被用作于提供數(shù)學(xué)函數(shù)的兩個輸入值。
當(dāng)printMathResult被調(diào)用時，它傳遞addTwoInt函數(shù)，以及整數(shù)值3和5。它使用3和5，調(diào)用addTwoInt函數(shù)，并打印函數(shù)運(yùn)行的結(jié)果8。
printMathResult的作用是調(diào)用一個適當(dāng)類型的數(shù)學(xué)函數(shù)并打印相應(yīng)結(jié)果。那是什么功能的實(shí)現(xiàn)其實(shí)并不重要，你只要給以正確的類型匹配就行。這使printMathResult以調(diào)用者類型安全的方式轉(zhuǎn)換了函數(shù)的功能。
函數(shù)類型的返回值
可以使用一個函數(shù)類型作為另一個函數(shù)的返回類型。返回的函數(shù)(->)即你的返回箭頭后，立即寫一個完整的函數(shù)類型就做到這一點(diǎn)。
下面的例子定義了兩個簡單的函數(shù)，分別是stepForward和stepBackward。stepForward函數(shù)返回輸入值自增1，而stepBackward函數(shù)返回輸入值自減1。這兩個函數(shù)都有一個相同的類型 (Int) -> Int：
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
這里有一個chooseStepFunction函數(shù)，它的返回類型是”函數(shù)類型(Int) -> Int”。chooseStepFunction返回一個基于布爾參數(shù)的stepBackward或stepForward函數(shù)類型:
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
您現(xiàn)在可以使用chooseStepFunction選擇一個函數(shù),可能是加一函數(shù)或另一個:
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function
上述例子可以判斷步驟的正負(fù)決定是否需要移動使得currentValue變量逐步接近零。currentValue初始值是3，這意味著當(dāng)前值>0，則返回true，chooseStepFunction返回stepBackward函數(shù)。返回函數(shù)的引用存儲在一個稱為moveNearerToZero常量里。
如今moveNearerToZero執(zhí)行了正確的功能，就可以用來計數(shù)到零：
println("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
println("/(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
println("zero!")
// 3...
// 2...
// 1...
// zero!
5、嵌套函數(shù)
迄今為止所有你在本章中遇到函數(shù)都是全局函數(shù)，在全局范圍內(nèi)定義。其實(shí)你還可以在其他函數(shù)中定義函數(shù)，被稱為嵌套函數(shù)。
嵌套函數(shù)默認(rèn)對外界是隱藏的，但仍然可以調(diào)用和使用其內(nèi)部的函數(shù)。內(nèi)部函數(shù)也可以返回一個嵌套函數(shù)，允許在嵌套函數(shù)內(nèi)的另一個范圍內(nèi)使用。
你可以重寫上面的chooseStepFunction例子使用并返回嵌套函數(shù)：
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!
