Swift函数与闭包

1.Swfit语法中使用func关键字来申明函数

func sayHi(){
    println("Hi !")
}

结果显示：Hi !

2.带参数和返回值函数，参数为String，返回值为String的函数

func sayHiToPerson(personName:String) ->String{
    return "Hi ! " + personName;
}
println(sayHiToPerson("Girl"))

结果显示：Hi ! Girl

3.外部参数名，在使用的时候会有相应的提示，若外部参数名跟局部参数一样的话只要加个#就可以了

func area(宽 a:Double , 高 b:Double) -> Double{
    return a * b;
}
println(area(宽: 3.0, 高: 3.0))

func area(#a:Double , #b:Double) -> Double{
    return a * b;
}
println(area(a: 3.0, b: 3.0))

结果显示：9.0
结果显示：9.0

4.可变参数，可变参数就是表示如果参数比较多的情况下可以使用 "类型..." 来表示多个参数
a.个函数只能接纳一个可变参数
b.一个可变参数必须位于函数的最后

func sum(x:Int...) -> Int{
    var t:Int = 0
    for v in x{
        t+=v
    }
    return t
}
println(sum(1,2,3,4,5,6))

结果显示：21

5.默认参数，就是当参数未填入时，该参数会传入一个默认参数为ta的值

func sayWhat( who:String = "Lucy" , what:String){
    println("\(who) say \(what)")
}
sayWhat(who: "Tom", "Hello")

结果显示：Tom say Hello

6.变量形参，默认的参数都是为常量，这里也可以定义一个变量形参

func fac(var x:Int) -> Int{
    var s:Int = 1
    while x > 1{
        s*=x--
    }
    return s
}
println(fac(5))

结果显示：120

7.In-Out形参，来交换两个数

func swap(inout a:Int ,  inout b:Int){
    a = a^b;
    b = a^b;
    a = a^b;
}
var a:Int = 1
var b:Int = 3
swap(&a,&b)//传入的实际是a和b的地址
println("交换之后结果为：a=\(a) b=\(b)")

结果显示：交换之后结果为：a=3 b=1

8.元组类型，没有返回值的函数总返回Void，在swift中，Void表示一个元组，无返回值即是一个空元组

func areaWithCircum(#width:Int ,#height:Int) -> (Int , Int){
    return (width*height , (width+height)<<1)
}
println(areaWithCircum(width: 4, height: 4))

结果显示：(16, 16)

9.函数类型，冒号后面是个函数 (Double ,Double) -> Double
a.函数类型可以定义一个常量或者变量

var areaFunc:(Double ,Double) -> Double = area
println(areaFunc(3.0,3.0))

结果显示：9.0

b.函数类型可以做为参数类型

func printlnArea(area:(Double,Double)->Double,width:Double,height:Double){
    println("\(area(width , height))")
}
printlnArea(areaFunc,3,3)

结果显示：9.0

c.函数类型做为返回类型，因为getMathFunc返回的是一个函数........这个函数的参数又是Int，所以需要传入一个参数......

当然也可以写成getMathFunc(type:"squre")(10)

func squre(a:Int) -> Int{
    return a*a
}
func cube(a:Int) -> Int{
    return a*a*a
}

func getMathFunc(#type:String) -> (Int) -> Int{
    if type == "squre"{
        return  squre
    }
    else{
        return cube
    }
}
var mathFunc = getMathFunc(type:"squre")
println(mathFunc(10))

结果显示：100

10.函数嵌套，函数嵌套就是一个函数中包含另一个函数

func getArea(type:String) -> (Int) -> Int{
    func squre(a:Int) -> Int{
        return a * a
    }
    func cube(a:Int) -> Int{
        return a * a * a
    }
    switch type{
    case "squre":
        return squre
    default:
        return cube
    }
}

var getAreaInstance = getArea("squre")
println(getAreaInstance(4))

结果显示：16

在getArea中的squre函数离开getArea就会被销毁，所以squre和cube的函数名没有任何的意义！所以可以使用闭包来简化嵌套函数的写法～

//闭包表达式
//{
//    (形参列表) -> 返回值类型 in
//        可执行表达式
//}

func getArea1(type:String) -> (Int) -> Int{
    switch type{
    case "squre":return {
            (Int) -> Int in
            return a * a
    }
    default:
        return{
            (Int) -> Int in
            return a * a * a
        }
    }
}

仔细观察上面的代码，其实就是 " { xxx  in  xxx  } " 的形式， 前面的xxx 就是" 参数列表 -> 返回类型 " ，后面的xxx 就是表达式...

另外~swift闭包可以通过上下文分析出参数列表，参数列表可以使用$0$1....$n这种方式表示。于是新的写法又出现了~

var result: Int  = {
    var result = 1
    for i in 1...$1{
        result *= $0
    }
    return result
}(3 , 4)
println(result)

结果显示：81

11.尾随闭包，指函数的参数类型为闭包类型

func someFunction (num : Int ,  fn: (Int)-> (Int)){
    //执行代码
    println(num * fn(10))
}
someFunction(20,{ $0 * $0 })

结果显示：2000

捕获上下文中的变量或者常量，总之闭包这个东西很灵活！慢慢分析都是能够弄清楚的～

func makeArr (ele: String) -> ()->[String]{
    var arr : [String] = []
    func addElement() -> [String]{
        arr.append(ele)
        return arr
    }
    return addElement
}
println(makeArr("Lucy")())

结果显示：[Lucy]