Swift 基础学习(闭包)

/*
(1)闭包的概念和分类
自包含的函数代码块
全局函数 (有名)
闭包表达式 (匿名) -- 能补货上下文中的常量或者变量
嵌套函数 (*)
*/

/*
(2)闭包表达式的语法
//函数表达式
func funcName(参数) -> 返回值类型 {
执行语句
}
//闭包表达式
{ (参数) -> 返回值类型 in
执行语句
}
*/

//无参无返回值的闭包表达式
let sayHello = {
print("hello World")
}
sayHello()
//有参数有返回值
let add: (Int, Int) -> Int = { (a: Int, b: Int) -> Int in
return a + b
}
print(add(1, 8))

/*
(3)闭包表达式回调用法
*/

//对数组进行排序
var array = [23,2,5,89,56]
func showArray (array: [Int]) {
for x in array {
print("\(x) ")
}
}
func bubbleSort(inout array: [Int]) {
let cnt = array.count
for var i = 1; i < cnt; i++ {
for var j = 0; j < cnt-i; j++ {
if (array[j] > array[i]){
let t = array[j]
array[j] = array[j+1]
array[j+1] = t
}
}
}
}
showArray(array)
bubbleSort(&array)
showArray(array)

//闭包表达式作为bubbleSort1一个函数的实参直接传递给函数
func bubbleSort1(inout array: [Int],cmp:(Int, Int) -> Int) {
let cnt = array.count
for var i = 1; i < cnt; i++ {
for var j = 0; j < cnt-i; j++ {
if (cmp(array[j], array[j+1]) == -1){
let t = array[j]
array[j] = array[j+1]
array[j+1] = t
}
}
}
}
let intCmp = {
(a: Int, b: Int) -> Int in
if a > b {
return -1
}else if a < b {
return 1
}else{
return 0
}
}
bubbleSort1(&array, cmp: intCmp)
showArray(array)

//如果按照个位数大小进行排序,只需修改闭包里面的方法即可
let intCmp1 = {
(a: Int, b: Int) -> Int in
let x = a % 10, y = b % 10
if x > y  {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
bubbleSort1(&array, cmp: intCmp1)
showArray(array)

/*
闭包表达式语法的优化
*/
//可以省略参数的类型,前提是在bubbleSort1函数中已经声明过类型,这里利用Swift的编译推断机制
bubbleSort1(&array) {  (a, b)  in
let x = a % 10, y = b % 10
if x > y  {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
showArray(array)
//也可以优化为如下
bubbleSort1(&array) {
//第一个参数用$0表示,后面的参数一次类推
let x = $0 % 10, y = $1 % 10
if x > y  {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
showArray(array)

/*
(5)尾随闭包
*/

//使用系统方法排序
var array1 = [5,2,56,23,90,67]
//降序
array1.sortInPlace { (a, b) -> Bool in
return a > b
}
showArray(array1)
//升序
array1.sortInPlace {
$0 < $1
}
showArray(array1)

/*
(6)嵌套函数:在函数内部定义实现的函数
*/

func bubbleSortFunc(inout array: [Int]) {
let cnt = array.count
//可以在函数的内部声明一个函数,作用域从它定义的开始到它所在函数的结束,仅仅为该函数服务;
func swapValue(inout a:Int, inout b:Int){
//内部可以访问bubbleSortFunc函数内部定义的局部变量
print("数组个数\(cnt)")
let t = a
a = b
b = t
}
for var i = 1; i < cnt; i++ {
for var j = 0; j < cnt-i; j++ {
if (array[j] > array[j+1]){
swapValue(&array[j], b: &array[j+1])
}
}
}
}
var array2 = [3,6,23,56,2,7]
bubbleSortFunc(&array2)
showArray(array2)

/*
(7)闭包捕获值
*/

//定义一个有参函数,返回值为一个闭包
func getIncFunc(inc: Int) -> (Int) -> Int {
func incFunc(v: Int) -> Int {
//inc是在外部定义的
return inc + v
}
return incFunc
}
let incFunc1 = getIncFunc(3)
//inc = 3,v = 10,结果是13
print(incFunc1(10))

func getIncFunc1(inc: Int) -> (Int) -> Int {
var mt = 10
func incFunc(v: Int) -> Int {
//mt为外部变量,incfunc可以捕获该值
mt++
return inc + v + mt
}
return incFunc
}
let incFunc2 = getIncFunc1(3)
//v=10,inc=3,mt=11,结果24
print(incFunc2(10))
//v=10,inc=3,mt=12此时记录了mt上次的值11,mt++之后变为12,结果为25;IncFunc捕获了mt值
print(incFunc2(10))

func getIncFunc2(inc: Int) -> (Int) -> Int {
func incFunc(v: Int) -> Int {
//声明为一个内部时,两次结果都是24
var mt = 10
mt++
return inc + v + mt
}
return incFunc
}
let incFunc3 = getIncFunc2(3)
let incFunc4 = getIncFunc2(3)
print(incFunc3(10))
print(incFunc3(10))
//每个返回的闭包都是独立,所以说mt并不会相互的受影响
print(incFunc4(10))