函数是一个组织在一起语句集合，以执行特定任务。Swift 函数类似于简单 C 函数以及复杂的 Objective C 语言函数。 它使我们能够通过函数调用内部的局部和全局参数值。 像其他任何语言一样 swift 函数也遵循相同的步骤。
函数声明：它告诉编译器有关的函数的名称，返回类型和参数。
函数定义：它提供函数的实际主体。
Swift 函数包含参数类型和返回类型。
函数定义
在Swift 语言中函数是由 “func” 关键字来定义。当一个新定义函数时，它可能需要一个或几个值作为函数输入作为“参数” ，它将被处理在函数体中并传回值作为 '返回类型' 输出。
每个函数都有一个函数名，它描述了函数将执行的任务。要使用函数，需要调用其名字函数，并通过它的输入值(称为参数)匹配函数的参数类型。函数参数也被称为“元组”。
函数的参数必须提供与函数参数列表的顺序相同，并返回一个值在 -> 之后。
语法
Syntax:
func funcname(Parameters) -> returntype
{
Statement1
Statement2
---
Statement N
return parameters
}
学生们的名字被声明为函数“student” ，函数内部声明字符串作为返回数据类型，当调用该函数将返回学生姓名。
func student(name: String) -> String {
return name
}
println(student("First Program"))
println(student("About Functions"))
当我们使用 playground 运行上面的程序，得到以下结果
调用函数
考虑下面的例子是一个用来显示数字的“display”函数，首先用参数 “no1” 初始化且持整数数据类型。 然后参数 “no1” 被分配给参数 “a”，指向相同的数据类型的整数。 现在参数 a 被返回给函数。这里 display()函数将持有整数值，每调用函数一次，返回整数值。
func display(no1: Int) -> Int {
let a = no1
return a
}
println(display(100))
println(display(200))
当我们使用 playground 运行上面的程序，得到以下结果
参数和返回值
Swift 提供了灵活的函数参数和返回值，从简单到复杂的值。类似于 C 和 Objective C 函数也可以有多种形式
带参数的函数
函数是通过其参数值传到函数体访问。我们可以通过单一到多元的参数值作为元组传到函数内部。
func mult(no1: Int, no2: Int) -> Int {
return no1*no2
}
println(mult(2,20))
println(mult(3,15))
println(mult(4,30))
当我们使用 playground 运行上面的程序，得到以下结果：
不带参数的函数
我们可能使用包含函数不带任何参数。
语法
func funcname() -> datatype {
return datatype
}
以下是不带参数函数的一个例子：
func votersname() -> String {
return "Alice"
}
println(votersname())
当我们使用 playground 运行上面的程序，得到以下结果
函数带返回值
函数也可用于返回字符串，整数和浮点数据类型值来作为返回类型。要找出数组函数 “ls” 的最大和最小的数，用large，small 整数数据类型声明。
数组初始化为持有整数值。然后数组被处理并将数组中的每一个值读出并写其先前的值比较。当该值比前一个存储在“small”的参数更小，否则存储在 “large” 的参数值通过调用函数返回
func ls(array: [Int]) -> (large: Int, small: Int) {
var lar = array[0]
var sma = array[0]
for i in array[1..<array.count] {
if i < sma {
sma = i
} else if i > lar {
lar = i
}
}
return (lar, sma)
}
let num = ls([40,12,-5,78,98])
println("Largest number is: /(num.large) and smallest number is: /(num.small)")
当我们使用 playground 运行上面的程序，得到以下结果
函数不带返回值
某些函数可能在函数中声明参数，但没有任何返回值。下面的程序声明 a 和 b 作为参数传递给 sum()函数。函数内部本身的参数 a 和 b 的值是通过调用所述函数通过调用 sum()，其值被打印从而不用返回相关值。
func sum(a: Int, b: Int) {
let a = a + b
let b = a - b
println(a, b)
}
sum(20, 10)
sum(40,10)
sum(24,6)
当我们使用 playground 运行上面的程序，得到以下结果
返回 Optional 类型的函数
Swift 推出 “optional” 特性以通过引入一个安全对策来消除问题。 例如，考虑我们声明函数值返回类型为整数，但当函数返回一个字符串值或任何一个零值，会怎么样？ 在这种情况下，编译器会返回错误值。 “optional” 引入以摆脱这些问题。
可选(Optional )功能将采取两种形式 'value' 和 'nil'。我们会提到 'Optionals' 使用键保留字符 “?” 检查元组是否返回一个值或零值。
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)
}
if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
println("min is /(bounds.min) and max is /(bounds.max)")
}
当我们使用 playground 运行上面的程序，得到以下结果
'Optionals'被用来检查 'nil' 或垃圾值，从而消耗大量的时间调试，使代码的效率和可读性的用户。
函数局部VS外部参数名称 局部参数名称
局部参数名称仅在函数内部访问。
func sample(number: Int) {
println(number)
}
这里 func 示例参数数量被声明为内部变量，因为它是由函数 sample() 内部访问。在这里，“number” 被声明为局部变量，但下面的语句引用变量可使用函数外部。
func sample(number: Int) {
println(number)
}
sample(1)
sample(2)
sample(3)
当我们使用 playground 运行上面的程序，得到以下结果
外部参数名称
外部参数名称允许命名一个函数参数，使它们的目的更加明确。 命名两个函数的参数，然后调用该函数如下
func pow(firstArg a: Int, secondArg b: Int) -> Int {
var res = a
for _ in 1..<b {
res = res * a
}
println(res)
return res
}
pow(firstArg:5, secondArg:3)
当我们使用 playground 运行上面的程序，得到以下结果
参数可变型参数
当我们想定义具有多个数量参数的函数, 那么我们可以声明成员为 “可变参数” 的参数。参数可以被指定为可变参数由(...)的参数名称之后。
func vari<N>(members: N...){
for i in members {
println(i)
}
}
vari(4,3,5)
vari(4.5, 3.1, 5.6)
vari("Swift", "Enumerations", "Closures")
当我们使用 playground 运行上面的程序，得到以下结果
常量，变量和 I/O 参数
函数默认情况下，考虑参数'常量'，其中的用户也可以声明参数到函数作为变量。我们已经讨论过 'let' 关键字用来声明常量参数，可变参数的定义是使用 “var” 关键字。
I/O参数在 Swift 中提供保留参数值的功能，即使其值在函数调用修改之后。在函数参数定义“inout”关键字的开始声明保留成员值。
它源于关键字“inout”，因为它的值传递 'in' 到函数并且它的值被访问，并它的函数体修改，函数返回到“out” 来修改原来的参数。
因为单靠它的值在里面，函数外部修改变量仅作为参数传递 in-out 参数。因此，没有必要声明字符串、文本作为 in-out 参数。 '&' 在之前变量名是指传递的参数。
func temp(inout a1: Int, inout b1: Int) {
let t = a1
a1 = b1
b1 = t
}
var no = 2
var co = 10
temp(&no, &co)
println("Swapped values are /(no), /(co)")
当我们使用 playground 运行上面的程序，得到以下结果
函数类型及其用法
每个函数遵循指定的函数通过输入参数，并输出所期望的结果。
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
下面是一个例子：
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
println(inputs(20,10))
println(inputs(36,6))
当我们使用 playground 运行上面的程序，得到以下结果
在这里，函数有两个参数 no1 和 no2 作为整数数据类型被初始化，它的返回类型也被声明为'int'
Func inputstr(name: String) -> String {
return name
}
在这里，函数声明为字符串数据类型。
函数也可能有无效(void)的数据类型来表示该函数将不返回任何东西。
func inputstr() {
println("Swift Functions")
println("Types and its Usage")
}
inputstr()
当我们使用 playground 运行上面的程序，得到以下结果
上述函数声明为没有参数并且函数的返回值为 void。
使用函数类型
函数首先传递 整数，浮点数或字符串类型的参数，然后如下所述其被作为常数或变量传递到函数中。
var addition: (Int, Int) -> Int = sum
这里 'a'和 'b' 声明作为 sum 函数的参数变量，在函数将这两个整数相加并返回：
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
println("Result: /(addition(40, 89))")
当我们使用 playground 运行上面的程序，得到以下结果
函数类型作为参数类型和返回类型
我们也可以通过传递函数本身作为参数类型给另一个函数。
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
println("Result: /(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
println("Result: /(addition(a, b))")
}
another(sum, 10, 20)
当我们使用 playground 运行上面的程序，得到以下结果
嵌套函数
嵌套函数通过调用内部函数来调用外部函数。
func calcDecrement(forDecrement total: Int) -> () -> Int {
var overallDecrement = 0
func decrementer() -> Int {
overallDecrement -= total
return overallDecrement
}
return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
println(decrem())
当我们使用 playground 运行上面的程序，得到以下结果：
函数参数传递
函数的语法格式如下：
func 函数名(参数列表) -> 返回值类型 {
语句组
return 返回值
}
关键字是func。
多个参数列表之间可以用逗号（,）分隔，也可以没有参数。
使用箭头“->”指示返回值类型。返回值有单个值和多个值。如果函数没有返回值，则“-> 返回值类型”部分可以省略。
如果函数有返回值，就需要在函数体最后使用return语句；如果没有返回值，则函数体中可以省略return语句。
函数定义示例代码如下：
funcrectangleArea(width:Double, height:Double) -> Double {
let area = width * height
return area
}
print("320x480的长方形的面积:/(rectangleArea(320, height:480))")
传递参数
介绍几种不同形式的参数。
使用外部参数名
为每个参数提供一个可以在函数外部使用的名称，称为外部参数名，修改rectangleArea函数的定义如下：
func rectangleArea(Wwidth:Double, H height:Double) -> Double {
let area = width * height
return area
}
在局部参数名之前给一个“外部参数名”，用空格分隔。定义代码中的W和H就是外部参数名。调用代码如下：
print("320x480的长方形的面积:/(rectangleArea(W:320, H:480))")
如果我们提供了外部参数名，那么在函数调用时，必须使用外部参数名，所以W和H不能省略。
省略外部参数名
Swift 2.0提供省略外部参数名可能，在定义函数时，使用下划线（_）表示外部参数名，示例代码如下：
funcrectangleArea(width:Double, _ height:Double) -> Double {
let area = width * height
return area
}
这样函数在调用时就可以省略外部参数名，代码如下：
print("320x480的长方形的面积:/(rectangleArea(320, 480))")
在定义函数时第一个参数不需要使用下划线（_），默认第一个参数名是省略的，其他参数名要想省略则需要使用下划线（_）符号。
参数默认值
在定义函数的时候可以为参数设置一个默认值，当调用函数的时候可以忽略该参数。看下面的一个示例：
func makecoffee(type :String = "卡布奇诺") -> String {
return "制作一杯/(type)咖啡。"
}
在调用的时候，如果调用者没有传递参数，则使用默认值。调用代码如下：
let coffee1 = makecoffee("拿铁")
let coffee2 = makecoffee()
最后输出结果如下：
可变参数
Swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数，它们具有相同的类型。我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数。
下面看一个示例：
func sum(numbers:Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total
}
下面是两次调用sum函数代码：
可以看到每次传递参数的个数是不同的。
