closure
func makeIncrement(amount: Int)- > () - >Int {
var total = 0
func increment(a) -> Int {
total + = amount
return total
}
return increment
}
let incrementByTen = makeIncrement(amount: 10)
print(incrementByTen())
print(incrementByTen())
print(incrementByTen())
Copy the code
- Escape a closure
- When a closure is passed as an actual argument to a function, and it is called after the function returns, the closure is said to have escaped. When you declare a function that accepts a closure as a formal argument, you can allow escaping when the formal argument is written ´@escaping to specify the closure
- One way closures can escape is by being stored in a variable defined outside the function.
- Automatic closure
- An automatic closure is a closure that is automatically created to be passed as an actual argument to a function expression. It takes no arguments, and when it is called, it returns the value of the internally packaged expression
- The advantage of this syntax is that you omit the parentheses surrounding the function-form arguments by writing regular expressions instead of displaying closures
- Automatic closures allow you to defer processing until its internal code runs until you call it
var names = ["zhangsan"."lisi"."wangwu"."zhangliu"]
let customerProvider = { names.remove(at: 0)}print(names.count)
print(customerProvider()) // Delay processing
print(names.count)
var providers:[()->String] = []
func collectCustomProviders(provider: @autoclosure @escaping() - >String) {
providers.append(provider)
}
collectCustomProviders(provider: names.remove(at: 0))
collectCustomProviders(provider: names.remove(at: 0))
print(names.count)
for p in providers {
print(p())
print(p())
}
print(names.count)
class SomeClass {
var x: String = "hello"
func doSomething(a) {
collectCustomProviders(provider: self.x) // The escape closure needs to be referenced using self}}Copy the code
Higher-order functions
-
map
- For each element in the original set, replace it with a transformed element to form a new set
-
filter
- For each primitive in the original set, the decision is made to discard it or put it in the new set
-
reduce
- For each element in the original set, it applies to the current cumulative result
-
flatmap
- For sets whose elements are sets, a single level set can be obtained
-
compactMap
- Filtration control
let numbers = [1.2.4.5.10]
print(numbers.map{ $0 * 10 })
print(numbers.filter{ $0 > 4 })
print(numbers.reduce(100) {$0 + The $1})
let arrayNumbers = [[1.2.3], [4.5.6], [7.8.9]]
print(arrayNumbers.flatMap{ $0.map{ $0 * 10 }})
let names: [String? ]= ["zhangsan"."lisi" , nil."wangwu"]
print(names.count)
print(names.compactMap {$0})print(names.compactMap {$0?.count} )
Copy the code