iOS - SwiftSwift开发实战

Swift closure闭包

2017-07-15  本文已影响130人  AKyS佐毅
闭包.png

究竟什么是Closure?

说的通俗一点,一个函数加上它捕获的变量一起,才算一个closure

//MARK: - 闭包等于特殊的函数closure expression就是函数的一种简写形式
简单来说,closure expression就是函数的一种简写形式。例如,对于下面这个计算参数平方的函数:

func add(num1: Int , num2 : Int) -> Int{
    return  num1 * num2
}
//MARK: -  声明了方法
var addExp :(Int,Int)-> (Int) = { (a,b) -> (Int) in
    return a * b
}

//MARK: - 用于定义addExpression的{}就叫做closure expression,它只是把函数参数、返回值以及实现统统写在了一个{}里。

let addExpression = { (m: Int ,n: Int) -> Int in
    return m * n
}
func exec(m: Int, n: Int ,result: (Int ,Int) -> (Int)) -> Int{
    return result(m,n)
}
add(num1: 2, num2: 4)

addExp(2,4)

addExpression(2,4)
exec(m: 2, n: 4) { (a:Int, b: Int) -> Int in
    return a * b
}

//MARK: - 什么是尾随闭包 将闭包信息写在第一个

func exect(result: (Int ,Int) -> (Int) ,m: Int, n: Int ) -> Int{
    return result(m,n)
}

//MARK: - 如果一个函数的参数,是一个闭包类型,那么默认情况下,是一个非逃逸的闭包。

exect(result: { (a, b) -> (Int) in
    return a * b
}, m: 2, n: 4)

//MARK: - @escaping 代表这个闭包是逃逸闭包,以后有可能被其他的闭包所使用,延长生命周期

func test(result: @escaping (Int ,Int) ->(Int)){
    result(2,4)
    
    let queue = DispatchQueue.init(label: "result")
    let time = DispatchTime.now() + DispatchTimeInterval.seconds(2)
    queue.asyncAfter(deadline: time) { 
        result(2,4)
    }
}
func square(n: Int) -> Int {
    return n * n
}

我们也可以这样来定义:

let squareExpression = { (n: Int) -> Int in 
    return n * n
}

并且,它们也都可以当作函数参数来使用:

let numbers = [1, 2, 3, 4, 5]
numbers.map(square) // [1, 4, 9, 16, 25]
numbers.map(squareExpressions) // [1, 4, 9, 16, 25]

在我们这个例子里,用于定义squareExpression的{}就叫做closure expression,它只是把函数参数、返回值以及实现统统写在了一个{}里。

没错,此时的{}以及squareExpression并不能叫closure,它只是一个closure expression。那么,为什么要有两种不同的方式来定义函数呢?最直接的理由就是,为了写起来更简单。Closure expression可以在定义它的上下文里,被不断简化,让代码尽可能呈现出最自然的语义形态。

例如,当我们把一个完整的closure expression定义在map参数里,是这样的:

numbers.map({ (n: Int) -> Int in 
    return n * n
})

首先,Swift可以根据numbers的类型,自动推导出map中的函数参数以及返回值的类型,因此,我们可以在closure expression中去掉它:

numbers.map({ n in return n * n })

其次,如果closure expression中只有一条语句,Swift可以自动把这个语句的值作为整个expression的值返回,因此,我们还可以去掉return关键字:

numbers.map({ n in n * n })

第三,如果你觉得在closure expression中为参数起名字是个意义不大的事情,我们还可以使用Swift内置的$0/1/2/3/4这样的形式作为closure expression的参数替代符,这样,我们连参数声明和in关键字也都可以省略了:

numbers.map({ $0 * $0 })

第四,如果函数类型的参数在参数列表的最后一个,我们还可以把closure expression写在()外面,让它和其它普通参数更明显的区分开:

numbers.map() { $0 * $0 }

最后,如果函数只有一个函数类型的参数,我们甚至可以在调用的时候,去掉():

numbers.map { $0 * $0 }

看到这里,你就应该知道当我们把closure expression用在它的上下文里,究竟有多方便了,相比一开始的定义,或者单独定义一个函数,然后传递给它,都好太多。但事情至此还没结束,相比这样:

numbers.sorted(by: { $0 > $1 }) // [5, 4, 3, 2, 1]

Closure expression还有一种更简单的形式:

numbers.sorted(by: >) // [5, 4, 3, 2, 1]

这是因为,numbers.sorted(by:)的函数参数是这样的:(Int, Int) -> Bool,而Swift为Int类型定义的>操作符也正好和这个类型相同,这样,我们就可以直接把操作符传递给它,本质上,这和我们传递函数名是一样的。

另外,除了写起来更简单之外,closure expression还有一个副作用,就是默认情况下,我们无法忽略它的参数,编译器会对这种情况报错。来看个例子,如果我们要得到一个包含10个随机数的Array,最简单的方法,就是对一个CountableRange调用map方法:

(0...9).map { arc4random() } // !!! Error in swift !!!
上一篇下一篇

猜你喜欢

热点阅读