纯粹记录一下自己学习函数这一块的内容，看官注意，没有干货
最简单的hello函数（没有参数，没有返回值）
func sayHello(){
print("hello word!!")
}
有参数没有返回值的函数
func sayHello(name:String){
print(name + "say hello word!! ")
}
//参数是数组的情况(两种写法都可以)
func parameterIsArray(art:[String]) {
//do something
}
func parameterIsArray(ary:Array<String>) {
//do something
}
//参数是字典的情况（两种写法都可以）
func parameterIsDictionaty(dictionary:Dictionary<String, AnyObject>) {
//do something
}
func parameterIsDictionaty(dictionary:[String:AnyObject]) {
//do something
}
如果传入的参数可以为空(也就是可以为nil)，可以用可选参数(默认的不是可选的)
func sayHello(name:String?){
if let name1 = name {//判断name是不是为空
print(name1 + "say hello word!! ")
}
}
有参数有返回值的(不是可选的单一的返回值)
func add2Nuber(a:Int, b:Int) -> Int{
return a + b
}
返回值可以是nil的函数
func add2Nuber(a:Int, b:Int) -> Int?{
if a + b < 10 {
return nil
}else{
return a + b
}
}
返回值是元组的函数
func getData(url:String) -> (data:Data?, error:Error?){
//write getData code
return (nil, nil)//注意这里不能返回nil，如果？写到元组外边可以返回nil，具体可以参照上边的函数写法
}
参数有默认值的情况(注意，默认参数要放在必须参数之后)
func sayHello(name:String, greeting:String = "Hello") -> String{
return greeting + " " + name
}
调用的时候，可以不用写greeting这个参数，不写就赋值的默认值
sayHello(name: "mike")//输出是 Hello mike
可变参数，类似系统的max函数
max(<#T##x: Comparable##Comparable#>, <#T##y: Comparable##Comparable#>, <#T##z: Comparable##Comparable#>, <#T##rest: Comparable...##Comparable#>)
这个函数可以求出很多参数的最大值，具体的参数个数，根据你输入的多少来确定，我们现在自己定义一个这样的函数，数字求和
func addSomeNumber(a:Int, b:Int, more:Int ...) -> Int {
var result = a + b
for number in more {
result += number
}
return result
}
调用的时候可以就是这样
addSomeNumber(a: 1, b: 2, more: 3, 4 ,5 ,6, 7)
注意，可变参数只能有一个，也只能放在参数列表的最后，所以，参数，默认参数，可变参数的顺序就知道了吧(1参数2默认参数3可变参数)
------------分割线-----------
再来讨论一下外部参数名和内部参数名，所谓外部参数名，就是调用函数的时候显示出来的参数名字，内部参数就是函数内部用的参数，不会在调用的时候显示出来，来个例子
func sayHello(name:String, greeting:String){
}
调用的时候看起来是这样的
sayHello(name:"mike", greeting:"hello")//name外部是可以看到的，这也是苹果默认的情况，
如果你想有一个更好的外部参数名，可以这样
func sayHello(userName name:String, greetWrod greeting:String){
//函数内部处理用的是name和greeting，前边的那两个只是为了外边看的
}
如果调用的时候，不想有外部参数名或者一些要一些不要，可以这样
func sayHello(_ name:String, greeting:String){
}
这样调用看起来是这样(有下横线的不会显示为外部参数名)
sayHello("mike", greeting: "hello")
如果你想用参数来做一些处理，比如
func to2(num:Int){
num /= 2
}
这样是会报错的，原因就是默认的num是let类型，常量参数是不能改变的，如果你在num前边加上一个var，在3.0之前，貌似是可以的但是，3.0之后就不行了，你可以这样写
func to2(num:Int){
var num1 = num
num1 /= 2
}
如果想改变传入参数的值，就需要用到inout，注意，2.x和3.x中的写法是不一样的，这里只写3.x的写法
交换传入的两个数字的值
func swap2Int(a:inout Int, b:inout Int){
let t = a
a = b
b = t
}
调用的时候，要传进去的就不是值而是一个地址，这就类似C中指针做为函数参数
var a = 3, b = 4
swap2Int(a: &a, b: &b)
调用之后，a，b的值就互换了
----------------分割线--------------
函数作为参数的用法
首先明白一点，函数也是一个类型，跟基本类型一样，可以这样写
func text1(a:Int, b:Int){
}
let text2:(Int, Int) -> () = text1//如果要显式的写出text2的类型，注意返回值是必须要写的，如果是没有参数没有返回值的类型，可以这样写let text3:() -> Void
所以函数也可以做为参数进行传递
现在有两个函数
func findBig(a:Int, b:Int) -> Int{
return a > b ? a : b
}
func findSmall(a:Int, b:Int) -> Int{
return a > b ? b : a
}
现在写一个函数，根据传入的是findBig还是findSmall来决定执行的结果
func find(a:Int, b:Int, rule:(Int, Int) -> (Int)) -> Int{
return rule(a, b)
}
调用的时候，可以这样
find(a: 3, b: 4, rule: findBig(a:b:))//这里也可以传入findSmall，就是找出两个数字小的那一个
那既然函数是一个类型，也必然可以作为返回值来使用，来个例子
两个函数都是计算税收的
func tax1(wage:CGFloat) -> CGFloat{
return 0.15 * wage
}
func tax2(wage:CGFloat) -> CGFloat{
return 0.2 * wage
}
func choseTaxFunction(wage:CGFloat) -> (CGFloat) -> CGFloat {
return wage <= 10000 ? tax1 : tax2
}
最后来一个计算税收的函数
func getTax(wage:CGFloat) -> CGFloat{
let getFunc = taxFunc(wage: wage)
return getFunc(wage)
}
总结一下函数最为参数和返回值的情况
作为参数，是已经知道要调用什么规则来处理数据。作为返回值，是根据数据来确定调用那一个处理方法。
稍微提一下函数嵌套，即使一个函数里可以再写一个函数，不会暴露在父函数之外，例如上边的例子可以这样写
func getTax(wage:CGFloat) -> CGFloat{
func taxFunc(wage:CGFloat) -> (CGFloat) -> CGFloat{
return wage <= 10000 ? tax1 : tax2
}//函数嵌套，外部不会暴露选择哪个处理方法
let getFunc = taxFunc(wage: wage)
return getFunc(wage)
}
