函数的定义与调用
1.当我们定义一个函数时，你可以定一个或多个有名字和类型的值，作为函数的输入称为参数；
2.当我们可以定义某种类型的值作为函数执行结束的输出称为返回类型；
3.每个函数都有一个函数名，用来描述函数执行的任务。要使用一个函数时，我们用函数名调用，并传入匹配的实参。一个函数的实参数必须与函数表里参数的顺序一致。
4.函数的定义：
func ＋ 函数名＋(参数列表) ＋ ->返回类型
5.函数调用：
函数名(实参列表)
函数参数与返回值
1.无参函数：函数可以没有参数。
func eat() -> String {
return "eating...."
}
print(eat())
2.多参数函数
函数可以有多种输入参数，这些参数被包含在函数的括号之中，以逗号分隔。
func eat(name:String , food:String)->String{
let result = "\(name) 在吃 \(food)";
return result
}
eat("小哥", food: "骨头")
当调用超过一个参数的函数时，第一个参数后的参数根据其对应的参数名称标记。
3.无返回值函数
函数可以没有返回值,因为这个函数不需要返回值，所以这个函数的定义中没有返回尖头和返回类型。
func test(){
print("just want to test")
}
test()
note:严格意义上来说，虽然我们没有返回值被定义，但是函数依然存在返回值。没有定义返回值类型的函数会返回特殊的值，叫Void。它其实是一个空的元组(tuple),没有任何元素，可以写成()。
4.被调用时，一个函数的返回值可以被忽略。
func test1(show:Bool) -> String {
if show {
print("show the View")
return "show success"
}
return "show fail"
}
func main(){
test1(true)
}
main()
note:返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致变异错误。
5.多重返回值函数
我们可以使用元组(tuple)类型让多个值作为一个复合值从函数中返回。
func minMax(arr:[Int]) -> (min:Int , max:Int) {
var min = arr[0]
var max = arr[0]
for item in arr {
if item < min {
min = item
}
if item > max {
max = item
}
}
return (min , max)
}
let result:(Int,Int) = minMax([1,23,44,11,3,5,6,66,4,78])
print("min is \(result.0) and max is \(result.1) ")
note:需要注意的是，元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了。
6.可选元组返回类型
如果函数返回的元组类型有可能整个元组都没有值，我们可以使用可选（Optional）元组返回类型反应整个元组可以是nil的事实。我们可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int,Int)?或(String,Int,Bool)?
note:可选元组类型如（Int,Int)?与元组包含可选类型如(Int?,Int?)是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每一个元素值。
func minMax(arr:[Int]) -> (min:Int , max:Int)? {
if arr.isEmpty {
return nil
}
var min = arr[0]
var max = arr[0]
for item in arr {
if item < min {
min = item
}
if item > max {
max = item
}
}
return (min , max)
}
if let result = minMax([1,3,4]) {
print("min is \(result.min) and max is \(result.max) ")
}else{
print("发生错误")
}
函数名称
函数参数都有有一个外部参数名和一个局部参数名。外部参数名用于在函数调用时标注传递给函数的参数，局部参数名在函数的实现内部使用。
func someFunction(firstparameterName:Int,secondParametername:Int){
//do something
}
someFunction(1, secondParametername: 2)
一般情况下，第一个参数会省略其外部参数名，第二个以及随后的参数使用其局部参数名作为外部参数名。所以参数必须有独一无二的局部参数名。尽管多个参数可以有相同的外部参数名，但不同的外部参数名能让你的代码更有可读性。
//这样会使可读性变差，不推荐
func someFunction(firstparameterName:Int,
secondParametername:Int,
secondParametername thridParametername:Int ){
//do something
}
someFunction(1, secondParametername: 2,secondParametername: 8)
指定外部参数名
我们可以在局部参数名前指定外部参数名，中间以空格分隔：
func someFuction(externalParameterName localParameterName: Int ){
//do something
}
note:如果你提供了外部参数名，哪么函数在调用时，就必须使用外部函数名。
使用外部函数名可以使函数以一种更富有表达性的类似句子的方式调用，并使函数体意图清晰，更具可读性。
忽略外部参数
如果我们不想为第二个以及后续的参数设置外部参数名，用一个下划线(_)代替一个明确的外部参数名。
func test(oneParameterName:Int, _ twoParameterName:Int){
//do something
}
test(1, 2)
note:因为第一个参数默认忽略其外部参数名称，显式地写下划线是多余的。
默认参数值
我们可以在函数定义中为每一个参数定义 默认值。当默认值被定义后，调用这个函数时可以忽略这个参数。
func someFunction(Parameter: Int = 20){
//do something
}
someFunction()
someFunction(100)
note:建议将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不通情况下调用时显得更为清晰。
func test(x:Int ,y:Int = 1, z:Int = 2,zz:Int){
print("do something")
}
test(1,zz:4)
test(1, y: 2, z: 3,zz:4)
test(1,z:3,zz:4)
test(1,y:3,zz:4)
在函数有多个默认值参数时，我们可以使用外部参数来明确指定赋值问题。
可变参数
一个 可变参数 可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入(...)的方式来定义可变参数。
可变参数的传入值在函数体中变为此类型的一个数组。
func maxDouble(items: Double...) -> Double? {
if items.isEmpty {
return nil
}
var max = items[0]
for item in items {
if max < item {
max = item
}
}
return max
}
let result = maxDouble(1,3,4,5.9,3,2)
if let max = result {
print("the max is \(max)")
}else{
print("出错了")
}
note:一个函数最多只能有一个可变参数。如果函数有一个或多个带默认值的参数，而且还有一个可变参数，哪么建议把可变参数放在参数列表的最后。
输入输出参数
1.函数参数默认是常量。在函数体内试图修改函数参数会出现编译期错误。
2.如果我们想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，哪么就可以把这个参数定义为输入输出参数。
3.定义一个输入输出参数时，在参数的定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
4.我们只能传递变量给输入输出参数。我们不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。
5.输入输出参数不能有默认值，如果我们用inout标记一个参数，这个参数就不能被var或者let标记。
func exchange(inout a a:Int , inout b:Int ){
let tmp = a
a = b
b = tmp
}
var x = 100, y = 200
print("x = \(x), y = \(y)")
exchange(a: &x, b: &y)
print("x = \(x), y = \(y)")
函数类型
每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
func function(a:Int , b:Int) -> Int {
return 1
}
func function2(){
}
上面函数的函数类型： (Int,Int) -> Int,可以解读为“这个函数类型有两个Int类型的参数，并返回一个Int型的值”。
下面函数的函数类型： () -> void , 可以被解读为“没有参数，并返回Void类型的函数”
使用函数类型
在swift中，使用函数类型就像使用其他类型一样。例如，我们可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
func function(a:Int , b:Int) -> String {
return "\(a) + \(b) = \(a+b)"
}
var funcVal: (Int,Int) -> String = function
let result = funcVal(1,2)
print(result)
1.我们可以将适当的函数赋值给函数类型的变量
2.我们可以使用函数变量来调用函数
3.有相同类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样
4.就像其他类型一样，将一个函数赋值给常量或变量时，我们可以让Swift来推断其函数类型
函数类型作为参数类型
我们可以用(Int,Int) -> Int这样的函数类型作为另一个函数的参数类型。这样我们就可以将函数的一部分实现留给函数的调用者来提供。
func add(x:Int,y:Int) ->Int {
return x + y
}
func handleData(function:(Int,Int)->Int,datas:[Int]) {
var handleResult = 0
for data in datas {
handleResult = function(handleResult,data)
}
print("handle result is \(handleResult)")
}
handleData(add , datas:[1,2,3,4,5,6,7,8,9])
函数类型作为返回类型
我们可以使用函数类型作为另一个函数的返回类型。我们需要做的就是在饭后箭头 -> 后写一个完整的函数类型。
func stepForward(input: Int) ->Int {
return input + 1
}
func stepBackWard(input: Int) ->Int {
return input - 1
}
func chooseFunc(forward :Bool) -> (Int)->Int {
if forward {
return stepForward
}else{
return stepBackWard
}
}
let function = chooseFunc(true)
let result = function(100)
print("result is \(result)")
嵌套函数
我们可以把函数定义在别的函数体中，这种函数被称为嵌套函数。默认情况下，嵌套函数时对外界不可见的，但是可以被它们的外围函数调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
func chooseFunc(forward :Bool) -> (Int)->Int {
func stepForward(input: Int) ->Int {
return input + 1
}
func stepBackWard(input: Int) ->Int {
return input - 1
}
if forward {
return stepForward
}else{
return stepBackWard
}
}
let function = chooseFunc(true)
let result = function(100)
print("result is \(result)")
