Swift：（七）、闭包

//闭包：闭包就是自包函数代码块，可以用来在代码中传递和使用。siwft中的闭包和C、OC中的代码块（block），以及其他语言的匿名函数类似

//全局函数和嵌套函数也是一种特殊的闭包，闭包采取的形式有三种：

//（1）、全局函数是一个有名字，但不会捕获任何值的闭包

//(2)、嵌套函数是一个有名字，并且可以捕获封闭函数域内值的闭包

//(3)、闭包表达式是一个利用轻量级愈发所写的可以捕获上下文中变量和常量的匿名闭包

//1、闭包表达式：sorted(by:)

let names = ["huangjingzheng","yuanliyin","jiadongliang","caoyinchu","lipengcheng"]

//用sorted(by:)来接受一个闭包，该闭包需要传入数组类型相同的两个值，并返回一个bool值类型的值来表示排序结束后第一个参数排在第二个参数后面还是前面 闭包类型：（String，String）－> Bool

func backFunction(_ s1:String,_ s2:String) ->Bool{

    return s1 > s2

}

//内联闭包

var newNames = names.sorted(by: backFunction)

print(newNames)

//2、闭包表达式的语法：可以是in－out参数，但不能设定默认值

//一般形式：｛（参数）－> reurnTepy in  函数题体 ｝

newNames = names.sorted(by: {(s1 :String,s2 :String) -> Bool in return s1 < s2})

print(newNames)

// 闭包的整体部分有关键字in引入，in表示闭包表达式参数和返回值类型已经定义完成，in后面进入闭包函数体

//3、系统自动推断类型,在swift中可以推断返回值和参数类型

newNames = names.sorted(by: { s1,s2 in return s1 > s2})

//4、单表达式闭包隐式返回：单行表达式可以通过省略return关键字来隐式返回单行表达式结果

newNames = names.sorted(by: {s1 ,s2 in s1 > s2})

print(newNames)

//5、参数名称缩写:系统可以进行类型的推断，可以省略in

newNames = names.sorted(by: {$0 < $1})

print(newNames)

//$0 和 $1 表示的是闭包中第一个参数和第二个String类型的参数

//6、运算符方法：

newNames = names.sorted(by: >)

//7、尾随闭包:需要将一个很长的闭包表达式作为一个参数传递给函数，提高函数的可读性，我们一般采用尾随闭包

func followFunction(close:()->Void){

    

}

//不使用尾随闭包进行函数调用：

followFunction(close: {

    //函数的主体

})

//使用尾随闭包进行函数调用

followFunction(){

    //函数的主体

}

newNames = names.sorted(by: {$0 < $1})

//使用尾随闭包：可以省略掉（）

newNames = names.sorted{$0 < $1}

//Array map（_:）

let dic = [0:"zero",1:"one",2:"tow",3:"three",4:"four",5:"five"]

let numbers = [16,58,2344]

//捕获值:闭包可以在其被定义的上下文捕获常量和变量

func getValue(age count:Int) ->()->Int{

    var total = 0

    func add()-> Int{

        total += count

        return count

    }

    return add

}

//var count = 10

//var total = 0

//func add()->Int{

//    total += count

//    return total

//}

let addFive = getValue(age: 5)

addFive()

let addOne = getValue(age: 1)

addOne()

print(addOne())

//闭包的引用：闭包和函数都是引用类型

let netadd = addOne

addOne()

print(addOne())

//逃逸闭包：一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们把这个就叫做闭包从函数中逃逸

//函数接受一个闭包作为参数，该闭包被添加到一个函数外定义的数组中，假如不标记@escaping，也就是允许逃逸，否则会编译报错

var completions:[()->Void] = []

func otherFunction(completion: @escaping ()->Void){

    completions.append(completion)

}

//@escaping：如果将一个闭包标记为escaping，那就意味着必须在闭包中显式self，如果式非逃逸闭包，就使用隐式self

func showFunc(close:()->Void){

    close()

}

class otherClass{

    var x = 1

    func doSomthing() {

        //逃逸闭包使用显式self

        otherFunction(completion: {self.x = 100})

        //非逃逸闭包使用隐式self

        showFunc(close: {x = 200})

    }

}

//自动闭包：自动闭包是一种自动创建的闭包，用于包装传递函数作为参数的表达式

var nameArr = ["dsfs","dfddddd","eeeeee","dfdfdfd"]

print(nameArr.count)//4

let customer = {nameArr.remove(at: 0)}

print(nameArr.count)//4

customer()

print(nameArr.count)

//在闭包代码块中，数组的第一元素被移除，在闭包调用之前元素永远不会被处，也就是说，闭包代码块中的表达式永远不会被执行