闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原域已经不存在,闭包仍然可以在闭包函数体内引用和修改这些值。
let sayhello = {
print("hello world")
}
let add:(Int,Int)->Int = {
(a:Int,b:Int) -> Int in
return a+b
}
var array = [20,2,3,70,8]
//array 自带排序函数sort
showArray(array)
print(array.sort())
bublleSort(&array,cmp: {
(a:Int,b:Int)->Int in
if(a>b){
return -1
}else if(a<b){
return 1
}else{
return 0
}
})
//闭包的优化
bublleSort(&array, cmp: {
if $0 > $1{
return -1
}else{
return 0
}
})
showArray(array)
/*
尾随闭包,闭包要放在函数的最后一个参数
**/
/*
Swift最简单的闭包形式是嵌套函数,也就是定义在其他函数的函数体内的函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
嵌套函数(函数内部声明的函数,作用域仅限于该函数)
值捕获
**/
let incresult = incfunc(3)
//这个值得说的是两个值是不同的,说明了值得到了保存
print(incresult(5))
print(incresult(5))
// Do any additional setup after loading the view, typically from a nib.
}
func incfunc(inc:Int) -> (Int)->Int {
var geta = 10
func incfuncs (incinside:Int)->Int{
geta += 1
return inc + incinside + geta
}
return incfuncs
}
func bublleSort(inout array:[Int] , cmp:(a:Int,b:Int)->Int) {
let cnt = array.count
for var i = 1 ; i<cnt ;i += 1 {
for var j = 0; j<cnt-i ; j+=1 {
if (cmp(a: array[j],b: array[j+1]) == -1) {
let a = array[j]
array[j] = array[j+1]
array[j+1] = a
}
}
}
}
func showArray(array:[Int]){
for x in array {
print("\(x)")
}
}