Swift详解之四-------妈妈再也不用担心我的闭包了

川长思鸟来 2022-08-04 09:14 185阅读 0赞

## 妈妈再也不用担心我的闭包了 ##

`注：本文为作者自己总结，过于基础的就不再赘述 ，都是亲自测试的结果。如有错误或者遗漏的地方，欢迎指正，一起学习。`

--------------------

swift中闭包是一个很强大的东西，闭包是自包含的函数代码块，可以在代码中被传递和使用。跟C 和 Objective-C 中的代码块(blocks)很相似 。这个大家必须掌握！必须掌握！必须掌握！`重要的事情要说三遍`

闭包可以捕获和存储其所在上下文中任意常量和变量的引用。 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。下面我们就来攻克它！

### 1、闭包函数 ###

官方在讲解闭包函数的时候一般都是使用一个`sort()` 的排序方法，我们来看看这个例子：

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
    func backwards(s1: String, s2: String) -> Bool {
        return s1 > s2
    }

这里我们定义了一个`String` 类型的数组，然后定义了一个`function`，接受两个 接收两个`String` 类型的参数，返回`bool`

然后我们来了解下`sort()` 我们这里对这个数组进行排序 按照我们定义的方法的规则，`var reversed = names.sort(backwards)`  
这个`sort()` 在swift 2.0加入数组，成为数组的成员方法可以直接调用 ，这里传入与数组类型相同的两个值 ,并返回`bool` ，如果返回true 就把第一个参数放在第二个前面 （也就是降序），反之你懂的

所以 ，我们这个函数的意思就是如果第一个比第二个参数大就返回true（s1>s2） ,所以是一个降序的排列 ，这里得到的结果是 ：`[Ewa, Daniella, Chris, Barry, Alex]`

大家看着官方的`sort()` 也看不到具体的实现，所以这块有可能不是很清楚 ，那么我们自己写一个排序 ，也传入我们这个函数。

func mySort (var arr:[String] , sortStr:(String,String)->Bool)->[String]
    {
        if(arr.count == 0){ return arr; }
    
        let count = arr.count
        var temp = ""
    
        for i in 0..<count
        {
           for j in i+1..<count
           {
                if(!sortStr(arr[i],arr[j]))
                {
                    temp = arr[i]
                    arr[i] = arr[j]
                    arr[j] = temp
                }
            }
        }
        return arr;
    }

者其实就是一个简单的冒泡排序 ，只不过把规则交给调用者 。  
调用方法 `mySort(names, sortStr: backwards)` 这里传入的是一个数组和一个函数类型 。得到结果 ：`[Ewa, Daniella, Chris, Barry, Alex]` 跟官方的sort一样的 。

下面的实例我们就用自己的sort 来讲，代码都在这里。大家可以看得明白 。

这里需要补充一个知识点。

区间运算 ：0...n  表示0-n的闭合区间  0..<n 表示一个包含0 不包含n半开半闭

### 2、闭包表达式语法 ###

然而这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)，但是我们还要写一个函数 ？ 当然不需要，下面我们用闭合表达式语法可以更好的构造一个内联排序闭包

闭包表达式语法有如下一般形式：
    { (parameters) -> returnType in
            statements
    }

闭包表达式语法可以使用常量、变量和inout类型作为参数，不提供默认值。 也可以在参数列表的最后使用可变参数。 元组也可以作为参数和返回值。

let arr1 = mySort( (names) , sortStr: { (s1:String,s2:String) -> Bool in
        return s1>s2
    })

这里我们把上面传入函数的地方，我们传入了一个闭包。这里就不做过多解释。完全按照上面的语法类型

*  根据上下文推断类型

因为我们写的`mySort` 第二个参数是类型为(String, String) -> Bool的函数，因此实际上String,String和Bool类型并不需要作为闭包表达式定义中的一部分。 因为所有的类型都可以被正确推断，返回箭头 (->) 和围绕在参数周围的括号也可以被省略：

所以我们的可以这样写 ：

let arr2 = mySort( (names) , sortStr: { s1,s2 in return s1>s2 })

看到没，智能的swift帮我们把闭包缩短了很多

*  单表达式闭包隐式返回

单行表达式闭包可以通过隐藏return关键字来隐式返回单行表达式的结果，我们这里是单行表达式 。  
`注：不要方便的用惯了多行表达式别也给省略了`

let arr3 = mySort( (names) , sortStr: { s1,s2 in s1>s2 })

我们的代码又短了很多

*  参数名称缩写  
    Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过0,1,$2来顺序调用闭包的参数。如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。 in关键字也同样可以被省略

这时候我们的闭包就变成了下面这样

let arr4 = mySort( (names) , sortStr: { $0>$1 })

哇！太厉害了，swift太强大了,你以为这是终极目标了，错了 还有更厉害的

*  运算符函数

Swift 的String类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值  
您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现  
最终我们的闭包变成了这样

let arr5 = mySort( (names) , sortStr: > )
    print(arr5) //[Ewa, Daniella, Chris, Barry, Alex]

*  尾随闭包

尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

let arr6 = mySort(names) { $0>$1 }

当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。这中方式也是我们经常时候的方式

### 3、捕获值 ###

闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

看到这段话是不是很晕呀，哈哈我们来看一个实例你就理解了 。

func makeRunStep(step:Int)->()->Int
    {
        var total = 0;
    
    //    func run()->Int {
    //        total+=step ;
    //        return total;
    //    }
        return {
       ()-> Int in  total+=step ;
                             return total; }
    }

这里我们定义了一个函数，传入一个`Int` ，返回`()->Int`的函数类型 。在函数中我们定义一个统计总数的变量`total` ，直接返回一个闭包 ，在闭包中使用传入的参数和变量`total` ,我们这里也可以用我注释的那段，写一个内嵌函数 ，然后返回这个内嵌函数 。

let ten = makeRunStep(10);

这里传入一个10 ，并把返回的函数类型赋值给一个常量ten 。  
执行该方法`ten()` 得到结果 10

当我们再去执行`ten()` 的时候，由于没有修改step，这里total实际上捕获并存储了该变量的一个副本，而该副本随着闭包一同被存储在ten这个变量中，因为每次调用该函数的时候都会修改total的值，闭包捕获了当前total变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeRunStep结束时候并不会消失，也保证了当下一次执行闭包时，total可以继续增加

所以得到的结果是 ：20

let ten = makeRunStep(10);
    ten()   //10
    ten()   //20
    ten()   //30
    ten()   //40
    let ten2 = makeRunStep(10);
    ten2() //10

如果重新调用`makeRunStep(7)` 则重新开始计数

let seven = makeRunStep(7);
    seven() //7
    seven() //14
    seven() //21
    seven() //28

大家看到这几组数据大概明白什么意思了吧， 其实真正的原因是闭包是一个引用类型的 ，`let ten = makeRunStep(10);` 我们这里虽然用一个常量接收了这个闭包，但是直接接受了它的引用，并不是闭包本身 。

let ten = makeRunStep(10);
    ten()   //10
    ten()   //20
    ten()   //30
    ten()   //40
    let ten1 = ten
    ten1() //50
    print(ten1()) //60

两个不同的常量可以同时引用一个闭包 。

关于闭包大致就这么多。如有疑问可以相互交流学习 。希望共同进步！

> 学习iOS，有他就够了，[小码哥视频，传智、黑马、各种swift书籍][swift]

[swift]: https://item.taobao.com/item.htm?spm=a230r.1.14.85.JFN9U2&id=529819836478&ns=1&abbucket=7#detail