函数
定义和调用函数
func sayHello(personName: String) -> String {
let greeting = "Hello, " + personName + "!"
return greeting
}
定义了一个名为sayHello，形参为String类型的常量personName,返回值类型为String.
函数的形参默认为常量，如果需要为变量，可以在personName前加上var。
无返回值的函数
func sayGoodbye(personName: String) {
println("Goodbye, \(personName)!")
}
多返回值的函数
使用一个元组类型作为函数的返回类型，来返回一个由多个值组成的复合返回值。
下面的例子定义了一个名为count函数，用来计算字符串中基于标准美式英语的元音、辅音以及字符的数量：
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)
}
外部形参名
可以向oc中一样为形参起一个外部名字。
func join(string s1: String, toString s2: String, withJoiner joiner: String)
-> String {
return s1 + joiner + s2
}
第一个形参的外部名称string，本地名称s1;第二个形参的外部名称toString，本地名称s2;第三个形参的外部名称是withJoiner，本地名称为joiner。
可以使用这些外部形参名称清楚明确地调用该函数：
join(string: "hello", toString: "world", withJoiner: ", ")
// returns "hello, world"
你可以写一次名字，并用一个hash符号（＃）作为名称的前缀。这就告诉Swift使用名称相同的本地行参名称和外部形参名称。
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"
默认形参值
指定joiner的默认值为“ ”
func join(string s1: String, toString s2: String,
withJoiner joiner: String = " ") -> String {
return s1 + joiner + s2
}
这样在调用该函数的时候可以不用传递joiner的值，当不传递该值时，joiner默认为“ ”。
join(string: "hello", toString: "world")
// returns "hello world"
若你有默认值得形参，但是未显示的指定外部形参名，其会有一个默认的外部形参名，就是其变量名。
如：没有为任何外部形参提供外部名，但仍然提供了joiner形参的默认值：
func join(s1: String, s2: String, joiner: String = " ") -> String {
return s1 + joiner + s2
}
在这种情况下，Swift为带默认值的形参提供了外部形参名，当调用该函数的时候，外部形参名必须让形参的目的明确无歧义：
join("hello", "world", joiner: "-")
// returns "hello-world"
可变形参
一个可变形参可接受零个或多个指定类型的值。当函数被调用时，你可以使用可变形参来指定--形参可以用来传递任意数量的输入值。可通过在形参的类型名后边插入三个点符号（...）来编写可变形参。
传递至可变形参的值在函数主体内是以适当类型的数组存在的。例如,一个可变参数的名称为numbers和类型为Double...在函数体内就作为名为numbers类型为Double[]的常量数组。
下边示例为任何长度的数字列表计算算术平均值：
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
注意：函数最多可以有一个可变形参，而且它必须出现在参数列表的最后，以避免使用多个形参调用函数引发歧义。如果你的函数有一个或多个带有默认值的形参，并且还有可变形参，请将可变形参放在所有默认形参之后，也就是的列表的最末尾。
In-Out 形参
变量形参只能在函数本身内改变。如果你想让函数改变形参值，并想要在函数调用结束后保持形参值的改变，那你可以把形参定义为in-out形参。
你只能传递一个变量作为in-out形参对应的实参。你不能传递一个常量或者字面量作为实参，因为常量和字面量不能被修改。当你把变量作为实参传递给in out形参时，需要在直接在变量前添加 & 符号，以表明它可以被函数修改。
提示：in-out参数不能有默认值，可变参数的参数也不能被标记为inout。如果您标记参数为inout，它不能同时被标记为var或let。
这里的一个叫做swapTwoInts函数，它有两个称为a和b的in-out整型形参：
func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
swapTwoInts函数只是简单地交换a、b的值。该函数通过存储一个名为temporaryA临时常量的值，指定b的值到a，然后分配temporaryA到b执行该交换。
你可以通过两个Int类型的变量调用swapTwoInts函数，从而交换它们的值。需要注意的是当它们被传递给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函数进行了修改，即使它们定义在函数外部。
函数类型
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
}
你可以定义一个常量或变量为一个函数类型，并为变量指定一个对应的函数：
var mathFunction: (Int, Int) -> Int = addTwoInts
可以解读为："定义一个名为mathFunction变量，该变量的类型为'一个函数，它接受两个Int值，并返回一个Int值。'设置这个新的变量来引用名为addTwoInts函数。"
现在你可以使用mathFunction来调用指定的函数：
println("Result: \(mathFunction(2, 3))")
// prints "Result: 5"
作为形参类型的函数类型
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "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函数，它的返回类型是"函数类型(Int) -> Int"。chooseStepFunction基于名为backwards的布尔形参返回stepBackward或stepForward函数:
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
嵌套函数（内部函数）
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! 