定义一个数组，并排序
let names= ["Chris","Alex","Ewa","Barry","Daniella"]
func backward( _ s1 : String, _ s2 : String) ->Bool{
return s1>s2
}
var reversedNames=names.sorted(by:backward) // 数组自带的排序方法 （排序方式使用自定义的函数backward）
// reversedNames is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
闭包其实就是没有函数名的方法
{ (parameters) -> return type in
statements
}
reversedNames=names.sorted(by: { (s1:String,s2:String) ->Boolin
returns1>s2
})
Inferring Type From Context // 从上下文推断类型
reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
Shorthand Argument Names // 缩写参数名
reversedNames = names.sorted(by: {$0>$1} )
Operator Methods // 操作符的方法
reversedNames=names.sorted(by: >)
Trailing Closures // 闭包作为函数参数 尾闭包
func someFunctionThatTakesAClosure(closure: () ->Void) {
// function body goes here
}
// Here's how you call this function without using a trailing closure:
someFunctionThatTakesAClosure(closure: {
// closure's body goes here
})
// Here's how you call this function with a trailing closure instead:
someFunctionThatTakesAClosure() { // 和上面的作用相同 将函数的闭包参数单独拎出来放在末尾
// trailing closure's body goes here
}
map() 这个方法有一个闭包的参数
let digitNames= [
0:"Zero",1:"One",2:"Two",3:"Three",4:"Four",
5:"Five",6:"Six",7:"Seven",8:"Eight",9:"Nine"
]
let numbers= [16,58,510]
let strings=numbers.map{
(number) -> String in
var number = number
var output = ""
repeat{
output = digitNames[number%10]! + output
number /= 10
}while number > 0
return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]
闭包可以从定义它的周围环境捕获常量和变量。 然后，闭包可以引用并修改那些常量和变量的值，即使定义常量和变量的原始作用域不再存在。
func makeIncrementer(forIncrement amount:Int) -> () ->Int{ // 这个方法返回一个函数
var runningTotal=0
func incrementer() ->Int{
runningTotal +=amount
return runningTotal
}
return incrementer
}
let incrementByTen = makeIncrementer(forIncrement:10) // 参数amount=10 incrementByTen 这个是 incrementer函数的函数类型 incrementByTen现在就是指向 incrementer 这个函数 ，并且 incrementer函数返回值runningTotal = 0
incrementByTen() //相当于调用了incrementer()函数 而且amount=10 runningTotal=10
// returns a value of 10
incrementByTen() //相当于调用了incrementer()函数 而且amount=10 runningTotal=20
// returns a value of 20
incrementByTen() //相当于调用了incrementer()函数 而且amount=10 runningTotal=30
// returns a value of 30
let incrementBySeven = makeIncrementer(forIncrement:7)
incrementBySeven()
// returns a value of 7
incrementByTen()
// returns a value of 40
Closures Are Reference Types //闭包是引用类型
Escaping Closures //当闭包作为参数传递给函数时，闭包被称为逃逸函数，但在函数返回后被调用。
var completionHandlers: [() ->Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping() ->Void) {
completionHandlers.append(completionHandler)
}
func someFunctionWithNonescapingClosure(closure: () ->Void) {
closure()
}
class SomeClass{
var x=10
func doSomething() {
someFunctionWithEscapingClosure{self.x=100}
someFunctionWithNonescapingClosure{x=200}
}
}
let instance=SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"
completionHandlers.first?()
print(instance.x)
// Prints "100"
