swift 8. 函数
标签（空格分隔）： swift
今天这一篇学习swift中的函数。函数在任何一门语言中都占据着举足轻重的地位，半边江山都是它的。所以，这一节我会很仔细的学的。
go!
函数的申明和调用
函数的申明
什么是函数，这个就不用说了吧。有过其他任何一门语言基础的人都应该了解，就不过多解释啥是函数了，函数是一块封闭打包好的代码块，以供其他地方调用。那么swift中function 是如何申明的呢？
swift中申明函数使用的关键字是func 。我了个擦，你特么的用完整的function这几个字母会不会死啊！！！好吧，既然你学人家的东西，就只能跟着人家走了。
先举个例子来看如何申明一个函数的：
func sayHello(personName: String) -> String {
let greeting = "Hello," + personName + "!"
return greeting
}
看，是不是觉得特别新奇，第一次见到这样子来写一个函数的。
用func作为关键字前缀，用来申明这是一个函数。然后加上函数名（function name，用来描述这个函数是来干嘛的。紧接着是参数，参数必须是这个样子的：(参数名 ：参数的类型)。可以有一个参数，也可以有多个，但都是这个样子书写的。返回值用箭头 -> 返回类型 这种方式来表示。
看明白了如何申明一个函数了吧，还是蛮简单的，相比其他语言中申明函数的方式，看完上面的之后，反而觉得这种方式还蛮清晰的。它很清晰定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么。
函数的调用
上面我们申明了2个函数sayHello 和 sayWord，那么如何调用他们呢？这一点每个语言都是一样的，直接用函数名(参数)就可以了。
var name = sayHello("yangyi")
print(name)
那么我们也可以一次性的调用并将结果打印出来：
print(sayHello("yangyi"))
值得注意的是：在你申明一个函数的参数是啥类型的时候，已经做了强制申明，所以在你调用这个函数传入的参数就一定是这个类型，不然会报错。
函数的参数与返回值
多个参数
一般函数，可以有一个参数，也可以有多个参数。和其他的语言一样，多个参数用,隔开
func funcName (参数名：参数的类型,参数名：参数的类型...){
}
func getInfo(name: String,country: String,age: Int) -> String {
//有3个参数
let info = "Hello,My name is " + name + "!" + " I'm from " + country + " I`m " + String(age) + " old now !"
return info
}
//调用并打印
print(getInfo("yangyi",country:"china",age:18))
//输出：Hello,My name is yangyi! I'm from china I`m 18 old now !
上面这个例子我们用了3个参数，2个String 和 1 个Int来作为参数，你可能注意到我用String(age)来强制转换了，因为swift中是不允许String 和 Int 不同的类型想加的，必须转换成同类型的，才可以，否则直接报错。
你可能注意到了这行：
getInfo("yangyi",country:"china",age:18)
第一个参数直接传入yangyi,第二个和第三个参数，却必须要加上参数名，否则编辑器报错。为什么要这样呢？这是因为苹果认为，其余的参数必须得显示的传入参数的名字，更好的让开发者知道这个参数是干嘛的。不容易顺序出错。我们下面讲到内部参数和外部参数时，会继续深究。
无参数
作为一个函数，肯定是有无参的情况的，即没有参数输入，swift中的函数无参数输入和其他语言一样，括号（）中留空就好了。
func sayHello() -> String {
return "hello"
}
//调用并打印函数
print(sayHello())
//输出：hello
无返回值
swift中参数的返回值的类型是通过 ->返回值 这种形式来书写的，那一个函数没返回值咋搞呢？还不简单，直接把->返回值 去掉就可以了啊！哈哈哈哈哈哈哈哈~
func sayHello() {
print("hello")
}
//调用无参数也无返回值的函数
sayHello()
多个返回值
一般现代的语言，返回值只有一个，要想返回多个值，要么是封装到一个数组当中返回，要么是对参数取值（&），再返回。所以基本就一个返回值。swift可以允许有多个返回值，借助于元组 类型返回。
元组在之前就讲过了，是()括号括起来的数据。所以。函数就变成这样了：
func funcName (string:String) -> (a:Int,b:Int) {
}
我们举例看下如何使用,下面的一个简单的例子，用来查找一个数组中的最小值和最大值。
//多个返回值
func findMaxAndMin(numbers:[Int]) -> (min:Int,max:Int){
var minValue = numbers[0]
var maxValue = numbers[0]
for number in numbers{
minValue = min(minValue,number)
maxValue = max(maxValue,number)
}
return (minValue,maxValue)
}
var scores:[Int] = [1,2,3,4,5,6]
var result = (findMaxAndMin(scores))
print("the min is \(result.min)") // 1
print("the max is \(result.max)") // 6
上面的例子可能太过简陋，对于传入参数值没做判断，对返回值也没做处理，可能会引起一些错误，我们结合之前学到的一些知识点，对这个函数进行加强，会用到 array.isEmpty,if,guard,Optional,if let 可选型解包等知识。
//多个返回值
func findMaxAndMin(numbers:[Int]) -> (min:Int,max:Int)?{
//判断是否为空，为空则返回nil
if numbers.isEmpty{
return nil
}
//保卫 不为空，否则返回nil
guard !numbers.isEmpty else{
return nil
}
//nil是可选型的标配，返回了nil，所以返回值也得加个？(min:Int,max:Int)?
// 表示返回值是可选型的，可能返回nil。
var minValue = numbers[0]
var maxValue = numbers[0]
for number in numbers{
minValue = min(minValue,maxValue)
}
var scores:[Int]? = [1,6]
scores = scores ?? []; // 用 ?? 确保scores 一定不为nil
if let result = findMaxAndMin(scores!){ // 强制解包，我们已经确定了scores不为nil
print("the min is \(result.min)") // 1
print("the max is \(result.max)") // 6
}
函数参数名称
外部函数参数名
我们在写一个函数的时候，使用的参数叫内部参数，就是说在这个函数内部使用
//定义了2个局部参数a和b
func sayHelloTo(a: String,b: String) -> String {
return "\(b),\(a)"
}
//调用时，只需要传入对应参数的值就可以了
sayHelloTo("yangyi",b:"hello"); // hello,yangyi
很显然，我并不是很清楚的知道参数a 和 b 是干嘛的。比较难以理解。
所以，现在出现了一种场景，就是我希望强制约束或者告诉调用者，我这几个参数是干嘛的？我想用用文字说明下，那么调用者就能一目了然的知道这几个参数是干嘛的。调用者调用时也必须带上这些参数名。
这就是外部参数名，来约束调用者。像这个样子约束，参数名前面空格加上外部参数名。还是刚才这个例子，如果我们要定义外部函数参数就可以这样：
func sayHelloTo(name a: String,withWord b: String) -> String {
return "\(b),\(a)"
}
//调用就加上外部参数名
sayHelloTo(name:"yangyi",withWord:"hello")
这样的好处就是，我们很清晰的告诉外部调用者，我每个参数是干嘛的，而且在我们的函数内部，我们仍然可以使用我们自己定义的比较简单的名字。
由于我们的函数名字sayHelloTo To 这个动词 就已经很清楚的说明我们的对象了，所以，第一个参数，可以不用外部参数名，这样更加清晰明了：
func sayHelloTo(a: String,\(a)"
}
sayHelloTo("yangyi",withWord:"hello")
默认条件下，如果我们不去声明第二个，第三个….他们的外部参数，那么内部参数名就是外部参数名。
简写外部参数名
上面的外部参数名的书写有点蛋疼，太长了。而且有时候不但没有起到规范和提示的作用，反而还有点碍事。
比如这个例子：
func mutiply(num1: Int,num2: Int) -> Int {
return num1*num2
}
上面定义了一个函数mutiply,计算2个整型的值的乘积。
由于，第二个参数，没有加外部参数名，所以，它的内部参数就是外部参数，那么调用就得这样：
mutiply(2,num2: 8) // 16
但是，这个函数其实足够简单，就是需要计算2个整型的乘积，这样一弄，调用者蛋疼的不行，估计会骂声一片，能不能省略掉第二个参数的外部名呢？答案是可以的。用 _ 。我们在 for，元组中都用了这个小下划线符号，表示忽略。
func mutiply(num1: Int,_ num2: Int) -> Int {
return num1*num2
}
mutiply(2,8) // 16
我们由此想到，系统提供给我们的函数，很多其实都是省略了外部参数名的,比如：
min(1,2)
max(3,6)
参数默认值
和其他语言中一样，一个参数是可以有默认值的，当这个参数不传，就会使用默认值。
像这样使用：
func sayHiTo(name:String,withWord word:String = "Hi") -> String{
return "\(word),\(name)"
}
sayHiTo("yangyi") // Hi,yangyi
sayHiTo("yangyi",withWord: "hello") // hello,yangyi
我们用的最多的函数print其实，他有好几个参数，只是后面几个参数，有默认值，我们就可以不用传了：
print(items: Any...,separator: String = " ",terminator: String = "\r\n") //separator 表示分隔符，就是同时输出几个字符，用什么隔开,默认是空格 //terminator 表示结束符，同时几个print输出时，用什么结束符，默认是\r\n换行
print(00,66)
print(77,88)
print(12,34,separator: "---",terminator: "!!!")
print(56,78,terminator: "....")
输出就是：
0 66
77 88
12---34!!!56---78....
可变参数
可变参数是一个好东西，在写一个函数时，可能有1个参数，可能有2个参数，可能有N个，也可能一个参数也没有。所以这样一来，内参就无法定义了。这个时候，可变参数就起到了很好的作用，很多语言中都有，swift中如何搞呢？
在变量类型名后面加入（…）来定义可变参数。
看这个例子
func addMutil(numbers: Int...) -> Int {
var total: Int = 0
for number in numbers {
total += number
}
return total
}
addMutil(1,4) // 10
addMutil(1,2) // 3
addMutil() // 0
常量参数和变量参数
其实，应该叫形参和实参才更靠谱，形参就是在定义函数时，用得参数名字，实参就是调用这个函数传递的参数。在swift中，形参其实是一个常量参数，是只能被用，不能被改，举个例子：
func sayWord(name: String) -> String {
name = name + "hello"
return name
}
你这样子是会报错的：
“annot assign to value: ‘name’ is a ‘let’ constant
也是就是说不能给name常量重新复制。
那有什么办法解决这个问题呢？我就是希望复用这个值，或者需求就是希望这这个参数值上做改动呢？
当有办法：在参数名前面空格加上var来申明这个一个变量参数。
func sayWord(var name: String) -> String {
name = name + "hello"
return name
}
这样就可以了。这样name 参数就变成一个变量参数了。可以改变自己的值了。
但是这样子其实只是改变了函数的返回值，并没有改变 name 这个字符串的值，只是我们偷懒在函数里复用了这个name值。
func sayWord(var name: String) -> String {
name = name + "hello"
return name
}
var name = "yangyi"
sayWord("yangyi") //返回yangyihello
name //任然是 yangyi
但是，swift3中会取消 var 这种申明的方式。
输入输出参数
用var 什么一个变量参数，仅仅只能在函数体内被更改，而且在swift3中被改变了，那如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数，用关键字inout标识。就是进去之后还会出来。调用的时候加上&,类似于C语言里的取地址运算。
func sayWord(inout name: String) -> String {
name = "hello" + name
return name
}
var myname = "yangyi";
satHello(&myname);
print(myName); //输出：helloyangyi
这样就改变了变量的值。
再看一个例子，用元祖的交换2个变量的值。
func swapTwoNum(inout num1: Int,inout _ num2: Int){
(num1,num2) = (num2,num1)
}
var num1 = 1
var num2 = 2
swapTwoNum(&num1,&num2)
print(num1) // 变成 2
print(num2) // 变成 1
函数类型
每个函数都有特定的类型，由参数的类型和返回值的类型决定的。例如，下面的这个个函数：
func sayHello(name: String,country: String) -> String {
let info = "Hello," + name + "!" + " I'm from " + country
return info
}
它的函数类似就是(String,String) -> String 可以读作“这个函数类型，它有两个 String型的参数并返回一个String 型的值。”
func add (a:Int,_ b:Int) -> Int{
return a + b
}
add 函数的函数类型就是 (Int,Int) -> Int
下面是另一个例子，一个没有参数，也没有返回值的函数：
func printHelloWorld() {
println("hello,world")
}
它是没有参数和返回的，那么它的函数类型就是() -> ()或者 Void->Void 没有指定返回类型的函数总返回 Void。在Swift中，Void 与空的元组是一样的。
使用函数类型
知道申明是函数类型之后，我们就可以使用它了，在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将函数赋值给它：
先定义函数addTwoInts
func add (a: Int,_ b: Int) -> Int {
return a + b
}
再赋值：
var mathFunction: (Int,Int) -> Int = add
(Int,Int) -> Int 作为一个类型合在一起，表示一个声明的是一个函数变量，这个函数变量有2个整型参数，返回值也是一个整型。
就像前面说过的定义原始的变量字符串String一样：
var myapp: String = "iphone"
这个可以读作：
“定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 add 函数”。
add 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。
print("Result: \(mathFunction(2,3))")
// print "Result: 5"
那么我们如何顶一个一个没有参数，也没有返回值的函数类型呢？
func helloWord(){
print( "hello word" )
}
//下面4种方式都是OK的。
var anthorHelloWord1:()->() = helloWord
var anthorHelloWord2:()->Void = helloWord
var anthorHelloWord3:Void->() = helloWord
var anthorHelloWord4:Void->Void = helloWord
函数类型作为参数类型
那么，你可能会疑惑了，这样蛋疼的申明一个函数类型，再赋给另一个变量，这样有啥意义呢。其实这样做，就是为了把函数当做一个参数传给给另一个函数。
看下面这个例子：
定义了一个函数：printMathResult ，第一个参数是个函数类型(Int,Int) -> Int,后面2个参数是2个整型。这样是将函数的一部分实现交由给函数的调用者。
看这个例子：
func printMathResult(mathFunction: (Int,Int) -> Int,_ a: Int,_ b: Int){ print("Result: \(mathFunction(a,b))") } printMathResult(mathFunction,5) // 8
这个函数第一个参数mathFunction 是一个(Int,Int) -> Int 类型的函数。在函数里直接打印这个函数调用。
再看另一个例子：
var a1:[Int] = [1,7,6]
a1.sort() //排序好了。[1,2,3,4,5,6,7]
a1.sort(isOrderedBefore: (Int,Int) -> Bool)
这个函数类型就是我们自定义排序规则，比如，我们想让大的数排在前面：
func sortDesc(a:Int,b:Int)-> Bool{
return a > b
}
a1.sort(sortDesc) // [7,1]
函数类型高阶函数
swift中的高阶函数，主要有这几个：map,filter,reduce。这3个函数，就是传入一个函数类型的变量。
array.map((Int) -> Int) 函数传入一个函数变量，数组的每一个值，都经过这个函数处理。
比如，我们希望改变数组中的每一个数组的值，都加2
var array2 = [1,5]
func plus2(num1:Int) -> Int{
return num1 + 2
}
array2.map(plus2) //[3,6,7]
array.filter((Int) -> Bool) 过滤。函数传入一个函数变量，数组中的每一个值都会经过这个函数处理，并会过滤掉一部分值。
func eg4(num1:Int) -> Bool{
return num1 > 4
}
array2.filter(eg4) // [5]
array.reduce(Int,combine: (Int,Int) -> Int) 累计函数。用来累加或者累减。把会第一个Int参数，作为combine的第一个参数，数组的第1个元素作为combine的第二个参数，combine返回的值，继续作为combine的第一个参数，第二参数取数组的第2个元素。依次循环。知道遍历完数组，最后计算的结果就是返回值。
var array2 = [1,5]
func add (a:Int,_ b:Int) -> Int{
return a + b
}
array2.reduce(0,combine: add) // 8
array2.reduce(0,combine: +) // 8直接用+ 也是表示相加
array2.reduce(0,combine: -) // -15 直接用+ 也是表示相加
array2.reduce(0,combine: *) // 0 因为有元素是0 ，所以相乘永远是0
函数类型作为返回类型
函数类型同样可以作为返回值，因为它就被当做一种类型，和普通的类型一样，所以也是可以返回的。你需要做的是在返回箭头 -> 后写一个完整的函数类型。我们再看这个例子：
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
上面分别定义了2个函数，函数类型都是 (Int) -> Int 类型的。一个是加1，一个是减1。
func chooseStepFunction(info: Bool) -> (Int) -> Int {
return info ? stepForward : stepForward
}
再定义一个函数 chooseStepFunction 参数是一个bool值，返回值是 (Int) -> Int这样的函数类型。有bool来决定，到底返回哪一个、
所以，我们这样调用：
let moveNearerToZero = chooseStepFunction(3 > 0) // moveNearerToZero ==函数 stepForward moveNearerToZero(1) //输出结果是2 let moveNearerToZero = chooseStepFunction(-3 > 0) // moveNearerToZero ==函数 stepBackward moveNearerToZero(1) //输出结果是0
嵌套函数
这章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。
默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
你可以用返回嵌套函数的方式重写 chooseStepFunction 函数：
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(1) // 0
var currentValue = 8
let moveNearerToZero = chooseStepFunction(currentValue < 0)
moveNearerToZero(1) // 9
