如今看cocoachina上得文章越来越有质量了，果断分享一下 

原文: http://www.cocoachina.com/newbie/basic/2014/0611/8773.html

函数

---

函数是运行特定任务的代码自包括块。

通过给定一个函数名称标识它是什么，并在须要的时候使用该名称来调用函数以运行任务。

 

Swift的统一的功能语法足够灵活的。可表达不论什么东西。不管是不带參数名称的简单的样式函数，还是带本地和外部參数名称的复杂的Objective-C样式方法。

參数可为简单函数调用提供默认值，而且能够被作为输入/输出參数传递，在函数运行完毕时改动传递来的变量。

 

Swift中的每一个函数都有一个类型，包括函数的參数类型和返回类型。你能够像使用Swift中其它类型一样使用该类型,这使得它很easy将函数作为參数传递给其它函数,甚至从函数中返回函数类型。函数也能够被写入其它函数中以在函数作用于中封装实用的功能。

 

定义和调用函数

---

当你定义一个函数时，你能够选择性地定义一个或多个名称，类型值作为函数的输入（称为形參）。或者定义一个函数结束后返回值的类型（称之为返回型）。每一个函数都有一个函数名。用来描写叙述了函数运行的任务。要使用一个函数时。可使用它的名称进行“调用”。并通过它的输入值（称为实參--argument）来匹配函数的參数类型。

一个函数的实參（arguments）必须始终和函数形參（parameter）顺序一致。

 

比如在以下的样例中被调用的函数greetingForPerson，像它描写叙述的那样 -- 它须要一个人的名字作为输入并返回一句针对那个人的问候语。为了实现该功能，你定义了一个输出參数--一个名为personName的字符串值，以及一个String返回类型，包括一个针对那个人的问候语：

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

全部这些信息都汇总到以func关键字为前缀的函数定义中。使用箭头->来指明函数的返回类型（一个连字符后跟一个向右的箭头），后边跟着返回的类型名称。

 

该定义描写叙述了函数的作用是什么，它期望接收什么，以及完毕后返回的结果。

该定义可轻易地让你在代码中的其它地方清晰明白地调用该函数：

1. println(sayHello("Anna")) 
2. // prints "Hello, Anna!" 
3. println(sayHello("Brian")) 
4. // prints "Hello, Brian!" 

你能够通过给它传递一个圆括号内String实參值来调用sayHello函数，比如sayHello（"Anna"）。

由于该函数返回一个String值，sayHello能够被包裹在一个println函数调用中来打印字符串。看看它的返回值，如上图所看到的。

 

sayHello的函数主体首先定义了一个新的名为greeting的String常量，并将其设置加上personName组成一句简单的问候消息。

然后这个greeting以关键字return来传回到函数外部。仅仅要return greeting被调用，函数运行完毕后就会返回greeting的当前值。

 

你能够通过不同的输入值多次调用sayHello的函数。上面的样例显示了假设使用"Anna"输入值调用它会发生什么，以及以"Brian"输入值调用时会发生什么。函数为每种情况量身定制了问候语。

 

为了简化这个函数的主体，可把消息创建和return语句合并成一行：

1. func sayHello(personName: String) -> String { 
2.     return "Hello again, " + personName + "!" 
3. } 
4. println(sayHello("Anna")) 
5. // prints "Hello again, Anna!" 

 

函数的形參和返回值

---

在swift中。函数的形參和返回值是很具有灵活性的。

你能够定义不论什么事情，不管是一个简单的仅有一个未命名形參的工具函数，还是那种具有丰富的參数名称和不同的形參选项的复杂函数。

 

多输入形參

函数能够有多个输入形參，把它们写到函数的括号内，并用逗号加以分隔。

以下这个函数设置了一个半开区间的開始和结束索引。用来计算在范围内有多少元素：

1. func halfOpenRangeLength(start: Int, end: Int) -> Int { 
2.     return end - start 
3. } 
4. println(halfOpenRangeLength(1, 10)) 
5. // prints "9" 

 

无形參函数

函数并没有要求一定要定义的输入形參。以下就是一个没有输入形參的函数。不论什么时候调用时它总是返回同样的String消息：

1. func sayHelloWorld() -> String { 
2.     return "hello, world" 
3. } 
4. println(sayHelloWorld()) 
5. // prints "hello, world" 

该函数的定义还须要在函数的名称后跟一对儿圆括号，即使它不带不论什么形參。

当函数被调用时函数名称也要跟着一对儿空括号。

 

无返回值的函数

函数不须要定义一个返回类型。这里有一个版本号的sayHello函数，称为waveGoodbye。它会打印自己的String值而不是返回它：

1. func sayGoodbye(personName: String) { 
2.     println("Goodbye, \(personName)!") 
3. } 
4. sayGoodbye("Dave") 
5. // prints "Goodbye, Dave!" 

 由于它并不须要返回一个值。该函数的定义不包括返回箭头（ - >）和返回类型。

提示：严格地说。sayGoodbye函数确实还返回一个值，即使未定义返回值。未定义返回类型的函数返回了一个Void类型的特殊值。这仅是一个空元组，这里边没有元素，能够被写成()。

当一个函数调用时它的返回值能够忽略不计：

1. func printAndCount(stringToPrint: String) -> Int { 
2.     println(stringToPrint) 
3.     return countElements(stringToPrint) 
4. } 
5. func printWithoutCounting(stringToPrint: String) { 
6.     printAndCount(stringToPrint) 
7. } 
8. printAndCount("hello, world") 
9. // prints "hello, world" and returns a value of 12 
10. printWithoutCounting("hello, world") 
11. // prints "hello, world" but does not return a value 

 第一个函数printAndCount。打印了一个字符串。然后并以Int类型返回它的字符数。

第二个函数printWithoutCounting，调用的第一个函数。但忽略它的返回值。当第二函数被调用时。消息由第一函数打印了回来。但没有使用其返回值。

提示：返回值能够忽略，但一个定义了返回值的函数则必须有返回值。 对于一个定义了返回类型的函数来说，假设没有返回值，那么将不同意控制流离开函数的底部。 假设试图这样做将出现一个编译时错误。

 

多返回值函数

你能够使用一个元组类型作为函数的返回类型，来返回一个由多个值组成的复合返回值。

 

以下的样例定义了一个名为count函数，用来计算字符串中基于标准美式英语的元音、辅音以及字符的数量：

1. func count(string: String) -> (vowels: Int, consonants: Int, others: Int) { 
2.     var vowels = 0, consonants = 0, others = 0 
3.     for character in string { 
4.         switch String(character).lowercaseString { 
5.         case "a", "e", "i", "o", "u": 
6.             ++vowels 
7.         case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", 
8.         "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z": 
9.         ++consonants 
10.         default: 
11.         ++others 
12.         } 
13.     } 
14.     return (vowels, consonants, others) 
15. } 

您能够使用此计数函数来对随意字符串进行字符计数，以检索一个包括三个指定Int值的元素统计总数：

1. let total = count("some arbitrary string!") 
2. println("\(total.vowels) vowels and \(total.consonants) consonants") 
3. // prints "6 vowels and 13 consonants" 

注意：这一点上元组的成员不须要被命名，元组是从函数中返回的，由于它们的名字已经被指定为函数的返回类型的一部分。

 

函数形參名

---

全部上面的函数都为其形參定义了形參名：

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

然而，这些參数名的仅能在函数本身的主体内使用。不能在调用函数时使用。这样的形參类型名称被称之为本地形參名（local parameter name），由于它们仅仅能在函数的主体中使用。

 

外部形參名

有时当你调用一个函数将每一个形參进行命名是很实用的，以表明你把每一个实參传递给函数的目的。

 

假设你希望使用你函数的人在调用函数时提供形參名称，那除了本地形參名外。你还要为每一个形參定义一个外部形參名称。你写一个外部形參名称在它所支持的本地形參名称之前,之间用一个空格来分隔:

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

提示：假设您为形參提供一个外部形參名称。那么外部形參名必须在调用时使用。

举一个样例，考虑以下的函数。通过在它们之间插入第三个"joiner"字符串来连接两个字符串：

1. func join(s1: String, s2: String, joiner: String) -> String { 
2.     return s1 + joiner + s2 
3. } 

 

当你调用这个函数，你传递给函数的三个字符串的目的就不是很清晰了：

1. join("hello", "world", ", ") 
2. // returns "hello, world" 

 

为了使这些字符串值的目的更为清晰,为每一个join函数形參定义外部形參名称:

1. func join(string s1: String, toString s2: String, withJoiner joiner: String) 
2.     -> String { 
3.     return s1 + joiner + s2 
4. } 

在这个版本号的join函数中，第一个形參的外部名称string。本地名称s1;第二个形參的外部名称toString。本地名称s2;第三个形參的外部名称是withJoiner，本地名称为joiner。

 

如今，您能够使用这些外部形參名称清晰明白地调用该函数：

1. join(string: "hello", toString: "world", withJoiner: ", ") 
2. // returns "hello, world" 

 使用外部參数名称使join函数的第二个版本号功能以更富有表现力,用户习惯的sentence-like方式调用函数,同一时候还提供了一个可读的、意图明白的函数体。

注意：在别人第一次阅读你的代码不知道你函数形參目的时候，就要考虑到使用外部形參名称了。 在调用函数的时候，假设每一个形參的目的清晰明白的话。那你就无需指定外部形參名。

 

外部參数名称速记

假设你想为一个函数提供一个外部形參名，然而本地形參名已经使用了一个合适的名称了，那你就不须要两次书写该形參的名称。相反，你能够写一次名字，并用一个hash符号（＃）作为名称的前缀。

这就告诉Swift使用名称同样的本地行參名称和外部形參名称。

 

这个样例定义了一个名为containsCharacter的函数,通过在本地形參名前加入hash符号(#)来定义外部形參名称。

1. func containsCharacter(#string: String, #characterToFind: Character) -> Bool { 
2.     for character in string { 
3.         if character == characterToFind { 
4.             return true 
5.         } 
6.     } 
7.     return false 
8. } 

 

该函数对形參名的选择使得其函数主题更加清晰易读。而且在调用该函数时也不会有歧义：

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

 

默认形參值

你能够为不论什么形參定义默认值以作为函数定义的一部分。

假设已经定义了默认值，那么调用函数时就能够省略该行參。

注意：请在函数形參列表的末尾放置带默认值的形參。这将确保全部函数调用都使用顺序同样的无默认值实參。并让在每种情况下清晰地调用同样的函数。

这里有一个早期的join函数，并为參数joiner设置了默认值：

1. func join(string s1: String, toString s2: String, 
2.     withJoiner joiner: String = " ") -> String { 
3.         return s1 + joiner + s2 
4. } 

 

假设在join函数调用时为joiner提供了字符串值，那么该字符串值能够用来连接两个字符串，就跟曾经一样：

1. join(string: "hello", toString: "world", withJoiner: "-") 
2. // returns "hello-world" 

 

可是，假设函数调用时没有为joiner提供值，就会使用单个空格（" "）的默认值：

1. join(string: "hello", toString: "world") 
2. // returns "hello world" 

 

有默认值的外部形參名

在大多数情况下,为全部形參提供一个带默认值的外部名是很实用的(因此要求)。

假设在调用函数的时候提供了一个值，那么这将确保形參相应的实參有着明白的目的。

 

为了使这个过程更easy，当你自己没有提供外部名称时，Swift将为你定义的不论什么默认形參提供一个自己主动外部名。

这个自己主动外部名和本地名一样，就像你已经在本地名前加入了hash符号（#）一样。

 

这里有一个早期join函数版本号，没有为不论什么外部形參提供外部名，但仍然提供了joiner形參的默认值：

1. func join(s1: String, s2: String, joiner: String = " ") -> String { 
2.     return s1 + joiner + s2 
3. } 

 

在这样的情况下。Swift为带默认值的形參提供了外部形參名。当调用该函数的时候，外部形參名必须让形參的目的明白无歧义：

1. join("hello", "world", joiner: "-") 
2. // returns "hello-world" 

注意：在定义形參时，你能够通过使用下划线(_)来取代显示外部名称。 只是在适当的情况下。带有默认值形參的外部名一般是优先推荐的。

可变形參

一个可变形參可接受零个或多个指定类型的值。

当函数被调用时，你能够使用可变形參来指定--形參能够用来传递随意数量的输入值。可通过在形參的类型名后边插入三个点符号（...）来编写可变形參。

 

传递至可变形參的值在函数主体内是以适当类型的数组存在的。比如,一个可变參数的名称为numbers和类型为Double...在函数体内就作为名为numbers类型为Double[]的常量数组。

 

下边演示样例为不论什么长度的数字列表计算算术平均值：

1. func arithmeticMean(numbers: Double...) -> Double { 
2.     var total: Double = 0 
3.     for number in numbers { 
4.         total += number 
5.     } 
6.     return total / Double(numbers.count) 
7. } 
8. arithmeticMean(1, 2, 3, 4, 5) 
9. // returns 3.0, which is the arithmetic mean of these five numbers 
10. arithmeticMean(3, 8, 19) 
11. // returns 10.0, which is the arithmetic mean of these three numbers 

注意：函数最多能够有一个可变形參，而且它必须出如今參数列表的最后。以避免使用多个形參调用函数引发歧义。 假设你的函数有一个或多个带有默认值的形參。而且还有可变形參，请将可变形參放在全部默认形參之后，也就是的列表的最末尾。

 

常量形參和变量形參

函数的形參默认是常量。试图在函数体内改变函数形參的值会引发一个编译时错误。这意味着你不能错误地改变形參的值。

 

可是有时候，函数有一个形參值的变量副本是很实用的。您能够指定一个或多个形參作为变量形參。从而避免在函数内部为自定义一个新的变量。变量參数是变量而很量,并给函数一个可改动的形參值副本。

 

在參数名称前用关键字var定义变量參数：

 
                       
                    
                    
 
                      




鲜花




握手




雷人




路过




鸡蛋