函数是一段完成特定任务的独立代码片段。你可以通过给函数命名来标识某个函数的功能，这个名字可以被用来在需要的时候"调用"这个函数来完成它的任务。
Swift 统一的函数语法非常的灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以既当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值将被修改。
在 Swift 中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在其他函数定义中，这样可以在嵌套函数范围内实现功能封装
函数的定义与调用
//带参数，带返回值
func sum(x : Int, y : Int) -> Int {
return (x + y)
}
print(sum(x: 10, y: 10))
//带参数，带返回值 元组
func maxAndMin(dataArr : [Int]) -> (maxInt:Int,minInt:Int) {
var currentMin = dataArr[0]
var currentMax = dataArr[0]
for value in dataArr[1..<dataArr.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
print(maxAndMin(dataArr: [5,7,3,4,9,7,1,6]))
//可选返回类型
func max(dataArr : [Int]) -> Int? {
var currentMin = dataArr[0]
for value in dataArr[1..<dataArr.count] {
if value < currentMin {
currentMin = value
}
}
return currentMin
}
if let min = max(dataArr: [5,7,3,4,9,7,2,6]){
print(min)
}else{
print("没有返回有效值")
}
//可选返回类型 元组
func maxAndMinOption(dataArr : [Int]) -> (maxInt:Int,minInt:Int)? {
var currentMin = dataArr[0]
var currentMax = dataArr[0]
for value in dataArr[1..<dataArr.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
let dataA:[Int] = [5,7,3,4,9,7,2,6]
if let (maxInt,minInt) = maxAndMinOption(dataArr: dataA){
print(maxInt,minInt)
}else{
print("没有返回有效值")
}
函数的参数标签和参数名称
每个函数参数都有一个参数标签( argument label )以及一个参数名称( parameter name )。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签
/函数的参数标签和参数名称
//默认情况下，函数参数使用参数名称来作为它们的参数标签
func getString(inputStr:String) -> String {
return "hello" + inputStr
}
print(getString(inputStr: "Edison"))
//指定参数标签
func getName(youEnglishName name: String) -> String {
return name + "hello"
}
print(getName(youEnglishName: "Edison"))
//忽略参数标签
func getAgeDes(_ age : Int) -> String {
return "your age is" + String(age)
}
print(getAgeDes(14))
默认参数值
你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
将不带有默认值的参数放在函数参数列表的最前。一般来说，没有默认值的参数更加的重要，将不带默认值的参数放在最前保证在函数调用时，非默认参数的顺序是一致的，同时也使得相同的函数在不同情况下调用时显得更为清晰
可变参数
一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。
可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做numbers 的 Double... 型可变参数，在函数体内可以当做一个叫numbers 的[Double] 型的数组常量
func avg(dataAll: Double...) -> Double {
var total : Double = 0
for num in dataAll {
total += num
}
return total/Double(dataAll.count)
}
print(avg(dataAll: 1,2,3,4,5,6,7,8,9))
输入输出参数
函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误(compile-time error)。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看输入输出参数一节。
你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改
//输入输出参数
func swapValue(valueA: inout Int,valueB : inout Int){
let valueTemp = valueA
valueA = valueB
valueB = valueTemp
}
var value1 = 11
var value2 = 22
swapValue(valueA: &value1, valueB: &value2)
print("new 1:\(value1),new 2:\(value2)")
函数类型
每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
func swapValue(valueA: inout Int,valueB : inout Int)
的类型： （Int:Int）-> Int
func swapValue2()
的类型： () -> Void
使用函数类型
在 Swift中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
//使用函数类型
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
var addTest : (Int,Int)->Int = addTwoInts
print("\(addTest(2,3))")
嵌套函数
到目前为止，本章节我们所见到的函数都称之为全局函数(global functions)，他们定义在全局域中，你可以把函数定义在别的函数体中，称之为嵌套函数(nested functions)
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
// 嵌套函数
func moreFun(x : Int , y : Int) -> Int {
func func1(p1 : Int) -> Int{
return p1 + 10
}
func func2(p2 : Int) -> Int{
return p2 + 20
}
return func1(p1: x) + func2(p2: y)
}
print("嵌套函数返回值:\(moreFun(x: 1, y: 2))")
//result:33
