Swift闭包的基本用法

• 闭包是自包含的函数代码块，可以在代码中被传递和使用。Switf中的闭包与C和Objective中的代码块(block)以及其他一些编程语言中的匿名函数比较相似
• 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量，俗称闭包
• 闭包的使用和block一样，用于保存一段代码，用作回调，用作执行耗时操作
• 闭包的格式: in关键字的目的是便于区分返回值和执行语句

 {
    (形参列表) -> 返回值类型
        in
    执行语句
 }

完整写法

let say:(String)->Void = {
  
  (name:String) -> Void in
  print("\(name)")
}
 say("hello")

没有返回值的写法

let say2:(String)->Void = {

  (name:String) in
  print("\(name)")

}
 say2("world")

没有参数没有返回值的写法

let say3: (Void) -> Void = {
  print("hello world")
}
say3()

冒泡算法写法一(普通写法)

var arr:Array<Int> = [31, 13, 52, 84, 5]
func bubbleSort( array:inout [Int]){

  let count = array.count
  for _ in 1...count-1 {
      
      
      for j in 0...count-2 {
          
          if array[j] > array[j+1] {
              let temp = array[j]
              array[j] = array[j+1]
              array[j+1] = temp
              
          }
      }
  }
}
bubbleSort(array: &arr)

冒泡算法写法二(使用闭包)

>经典用法
let cmp = {
  (a:Int,b:Int) -> Int in
  if a>b {
      return 1
  }else if a<b{
      return -1
  }else{
      return 0
  }
}

func bubbleSort(array:inout [Int],cmp:(Int,Int)->Int){
  let count = array.count
  for _ in 1...count-1 {
      for j in 0...count-2{
          if cmp(array[j],array[j+1]) == 1{
              let temp = array[j]
              array[j] = array[j+1]
              array[j+1] = temp
          }
      }
  }
}

var arr:Array<Int> = [31, 13, 52, 84, 5]
bubbleSort(array: &arr, cmp: cmp)

>闭包作为参数

  bubbleSort(array:&arr, cmp: {
  (a: Int, b: Int) -> Int in
  if a > b{
      return 1;
  }else if a < b
  {
      return -1;
  }else
  {
      return 0;
  }
 })
 
>如果闭包是最后一个参数, 可以直接将闭包写到参数列表后面, 这样可以提高阅读性. 称之为尾随闭包

  bubbleSort(array:&arr) {
  (a: Int, b: Int) -> Int in
  if a > b{
      return 1;
  }else if a < b
  {
      return -1;
  }else
  {
      return 0;
  }
}


>闭包表达式优化
// 1.类型优化, 由于函数中已经声明了闭包参数的类型, 所以传入的实参可以不用写类型
// 2.返回值优化, 同理由于函数中已经声明了闭包的返回值类型,所以传入的实参可以不用写类型
// 3.参数优化, swift可以使用$索引的方式来访问闭包的参数, 默认从0开始
bubbleSort(array:&arr){
//    (a , b) -> Int in
//    (a , b) in
  if $0 > $1{
      return 1;
  }else if $0 < $1
  {
      return -1;
  }else
  {
      return 0;
  }
}

如果是一条语句可以省略return

let hehe = {
  "我是小明"
}
print(hehe())

闭包捕获值

func getIncFunc(inc:Int) -> (Int) -> (Int){
    
    var max = 10
    
    func incFunc(x:Int) -> Int{
        max += 1
        print("incFunc函数结束")
        return max + x
    }
    
    // 当执行到这一句时inc参数就应该被释放了, 但是由于在内部函数中使用到了它, 所以它被捕获了
    // 同理, 当执行完这一句时max变量就被释放了,但是由于在内部函数中使用到了它, 所以它被捕获了
    print("getIncFunc函数结束")
    return incFunc
}

// 被捕获的值会和与之对应的方法绑定在一起, 同一个方法中的变量会被绑定到不同的方法中
let incFunc = getIncFunc(inc: 5)
print(incFunc(5))   //16
print(incFunc(5))   //17

let incFunc2 = getIncFunc(inc: 5)
print(incFunc2(5))  //16