函數(shù)是執(zhí)行特定任務的代碼自包含塊垂蜗。給定一個函數(shù)名稱標識, 當執(zhí)行其任務時就可以用這個標識來進行”調(diào)用”耗绿。
Swift的統(tǒng)一的功能語法足夠靈活來表達任何東西，無論是甚至沒有參數(shù)名稱的簡單的C風格的函數(shù)表達式这敬，還是需要為每個本地參數(shù)和外部參數(shù)設(shè)置復雜名稱的Objective-C語言風格的函數(shù)展辞。參數(shù)提供默認值，以簡化函數(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)用
當你定義一個函數(shù)時款违，你可以為其定義一個或多個不同名稱、類型值作為函數(shù)的輸入（稱為參數(shù)）群凶，當該函數(shù)完成時將傳回輸出定義的類型（稱為作為它的返回類型）插爹。
每一個函數(shù)都有一個函數(shù)名，用來描述了函數(shù)執(zhí)行的任務座掘。要使用一個函數(shù)的功能時递惋，你通過使用它的名稱進行“調(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ù)的作用是什么脂矫，它期望接收什么羹唠，以及當它完成返回的結(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í)行完畢是就會返回問候語的當前值侣诵。
你可以通過不同的輸入值多次調(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ù)選項的復雜函數(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ù)吹由。當函數(shù)被調(diào)用時函數(shù)名稱也要跟著一對空括號。
沒有返回值的函數(shù)
函數(shù)也不需要定義一個返回類型萍嬉。這里有一個版本的sayHello的函數(shù)壤追，稱為waveGoodbye行冰，它會輸出自己的字符串值而不是函數(shù)返回：
func sayGoodbye(personName: String) {
println("Goodbye, \(personName)!")
}
sayGoodbye("Dave")
// prints "Goodbye, Dave!"
因為它并不需要返回一個值，該函數(shù)的定義不包括返回箭頭（ – >）和返回類型肛走。
提示
嚴格地說朽色，sayGoodbye功能確實還返回一個值，即使沒有返回值定義梢褐。函數(shù)沒有定義返回類型但返
回了一個void返回類型的特殊值利职。它是一個簡直是空的元組，實際上零個元素的元組热押，可以寫為（）。
當一個函數(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ù)连锯，但忽略它的返回值拼弃。當?shù)诙瘮?shù)被調(diào)用時摇展，字符串消息由第一函數(shù)打印了回來肴敛，去沒有使用其返回值。
提示
返回值可以忽略不計吗购，但對一個函數(shù)來說医男，它的返回值即便不使用還是一定會返回的。在函數(shù)體底部
返回時與定義的返回類型的函數(shù)不能相容時捻勉，如果試圖這樣做將導致一個編譯時錯誤镀梭。
多返回值函數(shù)
你可以使用一個元組類型作為函數(shù)的返回類型返回一個有多個值組成的一個復合作為返回值。
下面的例子定義了一個名為count函數(shù)踱启，用它計來算字符串中基于標準的美式英語中設(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ù)來對任意字符串進行字符計數(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"
需要注意的是在這一點上元組的成員不需要被命名在該該函數(shù)返回的元組中，因為他們的名字已經(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ù)，因為它們只適用于函數(shù)體中使用。
外部參數(shù)名
有時當你調(diào)用一個函數(shù)將每個參數(shù)進行命名是非常有用的桥言，以表明你傳遞給函數(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
}
當你調(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)力,用戶習慣使用sentence-like的方式,同時還提供了一個可讀的、意圖明確的函數(shù)體春塌。
注意
考慮到使用外部參數(shù)名稱的初衷就是為了在別人第一次閱讀你的代碼時并不知道你函數(shù)參數(shù)的目的是什么。
但當函數(shù)調(diào)用時如果每個參數(shù)的目的是明確的和毫不含糊的驹愚，你并不需要指定外部參數(shù)名稱。
外部參數(shù)名稱速記
如果你想為一個函數(shù)參數(shù)提供一個外部參數(shù)名废睦，然而本地參數(shù)名已經(jīng)使用了一個合適的名稱了蕊退，你不需要為該參數(shù)寫相同的兩次名稱郊楣。取而代之的是，寫一次名字瓤荔，并用一個hash符號（＃）作為名稱的前綴。這告訴Swift使用該名稱同時作為本地參數(shù)名稱和外部參數(shù)名稱。
這個例子定義了一個名為containsCharacter的函數(shù),定義了兩個參數(shù)的外部參數(shù)名稱并通過放置一個散列標志在他們本地參數(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ù)的默認值
可以為任何參數(shù)設(shè)定默認值來作為函數(shù)的定義的一部分。如果默認值已經(jīng)定義水孩，調(diào)用函數(shù)時就可以省略該參數(shù)的傳值。
注意
將使用默認值的參數(shù)放在函數(shù)的參數(shù)列表的末尾玉罐。這確保了所有調(diào)用函數(shù)的非默認參數(shù)使用相同的順
序,并明確地表示在每種情況下相同的函數(shù)調(diào)用屈嗤。
這里有一個版本，是早期的join函數(shù)吊输，并為參數(shù)joiner設(shè)置了默認值：
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"
但是季蚂，如果當函數(shù)被調(diào)用時提供了joiner的沒有值茫船，就會使用單個空格（” “）的默認值
join(string: "hello", toString: "world")
// returns "hello world"
有默認值的外部名稱參數(shù)
在大多數(shù)情況下,為所有參數(shù)提供一個外部帶有默認值的參數(shù)的名稱是非常有用的(因此要求)。這將確如果當函數(shù)被調(diào)用時提供的值時參數(shù)必須具有明確的目的扭屁。
為了使這個過程更容易算谈，當你自己沒有提供外部名稱時，Swift自動為所有參數(shù)定義了缺省的參數(shù)外部名稱料滥。自動外部名稱與本地名稱相同然眼，就好像你在你的代碼中的本地名稱之前寫了一個hash符號。
這里有一個早期join函數(shù)版本葵腹，它不為任何參數(shù)提供的外部名稱高每，但仍然提供了joiner參數(shù)的默認值：
func join(s1: String, s2: String, joiner: String = " ") -> String {
return s1 + joiner + s2
}
在這種情況下，Swift自動為一個具有默認值的參數(shù)提供了外部參數(shù)名稱礁蔗。調(diào)用函數(shù)時觉义，為使得參數(shù)的目的明確雁社、毫不含糊浴井，因此必須提供外部名稱：
join("hello", "world", joiner: "-")
// returns "hello-world"
注意
你可以通過編寫一個下劃線(_)有選擇進行這種行為,而不是一個明確的定義外部參數(shù)名稱。然
而霉撵，在適當情況下有默認值的外部名稱參數(shù)總是優(yōu)先被使用磺浙。
可變參數(shù)
一個可變參數(shù)的參數(shù)接受零個或多個指定類型的值。當函數(shù)被調(diào)用時徒坡，您可以使用一個可變參數(shù)的參數(shù)來指定該參數(shù)可以傳遞不同數(shù)量的輸入值撕氧。寫可變參數(shù)的參數(shù)時，需要參數(shù)的類型名稱后加上點字符（…）喇完。
傳遞一個可變參數(shù)的參數(shù)的值時伦泥，函數(shù)體中是以提供適當類型的數(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ù)使用默認值，并且還具有可變參數(shù)防楷，將可變參數(shù)放在列表的
最末尾的所有默認值的參數(shù)之后牺丙。
常量參數(shù)和變量參數(shù)
函數(shù)參數(shù)的默認值都是常量。試圖改變一個函數(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,它對準一個輸入字符串羊异，以一個較長的輸出字符串。在左側(cè)的空間中填充規(guī)定的字符彤断。在該示例中野舶，字符串”hello”被轉(zhuǎn)換為字符串”—–hello”。
該alignRight函數(shù)把輸入?yún)?shù)的字符串定義成了一個變量參數(shù)宰衙。這意味著字符串現(xiàn)在可以作為一個局部變量平道，用傳入的字符串值初始化，并且可以在函數(shù)體中進行相應操作供炼。
函數(shù)首先找出有多少字符需要被添加到左邊讓字符串以右對齊在整個字符串中一屋。這個值存儲在本地常量amountToPad中。該函數(shù)然后將填充字符的amountToPad個字符拷貝到現(xiàn)有的字符串的左邊袋哼，并返回結(jié)果冀墨。整個過程使用字符串變量參數(shù)進行字符串操作。
注意
一個變量參數(shù)的變化沒有超出了每個調(diào)用函數(shù),所以對外部函數(shù)體是不可見的涛贯。變量參數(shù)只能存在于函數(shù)調(diào)用
的生命周期里诽嘉。
輸入-輸出參數(shù)
可變參數(shù)，如上所述弟翘，只能在函數(shù)本身內(nèi)改變虫腋。如果你想有一個函數(shù)來修改參數(shù)的值，并且想讓這些變化要堅持在函數(shù)調(diào)用結(jié)束后稀余，你就可以定義輸入-輸出參數(shù)來代替悦冀。
通過在其參數(shù)定義的開始添加inout關(guān)鍵字寫用來標明輸入-輸出參數(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ù)學函數(shù)addTwoInts和multiplyTwoInts。每個函數(shù)接受兩個int參數(shù)募闲，返回一個int值步脓，執(zhí)行相應的數(shù)學運算然后返回結(jié)果
這兩個函數(shù)的類型是(Int, Int)->Int可以解釋為：
這個函數(shù)類型它有兩個int型的參數(shù)，并返回一個int類型的值
下面這個例子是一個不帶任何參數(shù)和返回值的函數(shù)：
func printHelloWorld() {
println("hello, world")
}
這個函數(shù)的類型是()->()浩螺，或者函數(shù)沒有參數(shù)靴患，返回void。函數(shù)沒有顯式地指定返回類型要出，默認為void鸳君，在Swift中相當于一個空元組，記為()患蹂。
使用函數(shù)類型
在swift中你可以像任何其他類型一樣的使用函數(shù)類型或颊。例如，你可以定義一個常量或變量為一個函數(shù)類型传于，并指定適當?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ù)類型當你為常量或變量分配一個函數(shù)時:
let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int
函數(shù)類型的參數(shù)
可以使用一個函數(shù)類型唇辨，如(Int, Int)->Int作為另一個函數(shù)的參數(shù)類型。這使你預留了一個函數(shù)的某些方面的實現(xiàn)能耻，讓調(diào)用者調(diào)用函數(shù)時提供赏枚。
下面就以打印上面的數(shù)學函數(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ù)學函數(shù)的兩個輸入值沟饥。
當printMathResult被調(diào)用時，它傳遞addTwoInt函數(shù)复颈，以及整數(shù)值3和5蚓曼。它使用3和5亲澡，調(diào)用addTwoInt函數(shù)，并打印函數(shù)運行的結(jié)果8纫版。
printMathResult的作用是調(diào)用一個適當類型的數(shù)學函數(shù)并打印相應結(jié)果床绪。那是什么功能的實現(xiàn)其實并不重要，你只要給以正確的類型匹配就行其弊。這使printMathResult以調(diào)用者類型安全的方式轉(zhuǎn)換了函數(shù)的功能癞己。
函數(shù)類型的返回值
可以使用一個函數(shù)類型作為另一個函數(shù)的返回類型。返回的函數(shù)(->)即你的返回箭頭后梭伐，立即寫一個完整的函數(shù)類型就做到這一點痹雅。
下面的例子定義了兩個簡單的函數(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
上述例子可以判斷步驟的正負決定是否需要移動使得currentValue變量逐步接近零。currentValue初始值是3拌滋，這意味著當前值>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ù)默認對外界是隱藏的，但仍然可以調(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!
