Closures闭包

//: Playground - noun: a place where people can play

import UIKit

/*

闭包

Swift ====> Closures

Ruby OC ====> Block

Python C++11 ====> Lamba

Javescript =====> Anonymous Function(匿名函数)

*/

//冒泡排序

func sortInts(inout data : [Int], function : (Int,Int)->Bool) {

for var i = 0; i < data.count - 1; i++ {

for var j = 0; j < data.count-1-i; j++ {

if function(data[j], data[j+1]) {

swap(&data[j], &data[j+1])

}

}

}

}

func rule(a : Int, b : Int) ->Bool {

return a > b

}

func rule1(a : Int, b : Int) ->Bool {

return a < b

}

var a = [1, 3, 9, 0, 8, 2, 5, 7, 6, 4]

sortInts(&a, rule)

a

sortInts(&a, rule1)

a

//闭包函数 实际上就是函数 是匿名函数

//{

//    (parameters)->returnType in

//        //语句

//        retrun xxx

//}

sortInts(&a, {

//    (Int,Int)->Bool

(a : Int, b : Int)->Bool in

return a > b

})

a

func rule2(a : Int, b : Int)->Bool{

return a < b

}

sortInts(&a, {

(a : Int, b : Int)->Bool in

return a < b

})

a

//闭包函数有些事可以省略

//可以把参数类型省略，类型从传入的参数中推断出来

sortInts(&a, {

(a, b)->Bool in

return a < b

})

//可以把返回值省略，采用了追踪返回值类型

sortInts(&a, {

(a, b) in

return a < b

})

//如果只有一条语句， 可以省略return

sortInts(&a, {

(a, b) in a < b

})

//参数名可以不用写，使用默认的$0, $1, $2...来代替

sortInts(&a, { $0 < $1 })

//甚至可以直接省略参数，而直接使用运算符来表示函数的内容

sortInts(&a, >)

a

var i : Int = 10

func setNum(inout a : Int,function : (inout Int) ->()) {

function(&a)

}

setNum(&i, {

//(+5 , -10, 100)

(inout a : Int) in a+=20

})

func add_5(inout n : Int) {

n += 5

}

func add_10(inout n : Int) {

n += 10

}

func addArr(inout array : [Int], function : (inout Int)->() ) {

for var i = 0; i < array.count; i++ {

function(&array[i])

}

}

var array = [1, 2, 3, 4, 5]

addArr(&array, add_5)

array

addArr(&array, add_10)

array

//对字符串进行排序，用的是系统自带的排序函数

var names = ["aaa","cdc","add","bbb"]

sort(&names)

names

//Swift 的排序函数 > 从大到小

sort(&names, { (a, b) -> Bool in

a > b

})

sort(&names, <)

//sorted

//map()

let digitNames = [0:"零",1:"一",2:"二",3:"三",4:"四",5:"五",6:"六",7:"七",8:"八",9:"九"]

let numbers = [16, 58, 510]

//map是数组的方法，可以迭代数组中每一个元素传入闭包函数中执行一次，并执行结果生成一个新的数组返回出来

let strings = numbers.map( {

(var number) ->String in

var output = ""

while number > 0{

output = digitNames[number % 10]! + output

number /= 10

}

return output

}

)

let _is = numbers.map( {

(var number) ->Int in

var a = number + 50

return a

}

)

strings

var aa = 10

numbers

_is