Swift 笔记（六）

最新推荐文章于 2024-12-07 20:56:51 发布

原创最新推荐文章于 2024-12-07 20:56:51 发布 · 761 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#swift

Swift 专栏收录该内容

10 篇文章

订阅专栏

本文深入探讨了Swift语言中闭包的基础概念与应用技巧，包括闭包的定义、使用方式及语法简化等内容，并通过实例展示了如何利用闭包进行数值运算及变量捕获。

我的主力博客：半亩方塘

Closures

1、Closures are functions without names. Here's a declaration for a varible that can hold a closure:

var mutiplyClosure: (Int, Int) -> Int

You assign a closure to a variable like so:

multiplyClosure = { (a: Int, b: Int) -> Int in 
    return a * b
}  

With your closure variable defined, you can use it just as if it were a function, like so:
 
  let result = multiplyClosure(4, 2)
  

  As you'd expect, result equals 8.
  There are many ways to shorten their syntax:
  multiplyClosure = { (a: Int, b: Int) -> Int in
    a * b
}  

multiplyClosure = { (a: Int, b: Int) in
    a * b
}

multiplyClosure = { (a, b) in  
    a * b
}  

multiplyClosure = {
    $0 * $1
}  

  
   

  
  2、Consider the following code:
 
 
  
  func operateOnNumbers(a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
    let result = operation(a, b)
    print(result)
    return result
}  

  You can then use 
  operateOnNumbers
   with a closure, like so:
 
 
  
  let addClosure = { (a: Int, b: Int) -> Int in
    a + b
}
operateOnNumbers(4, 2, operation: addClosure)  
  

  You can define the closure inline with the operateOnNumbers function call, like this:
  
  operateOnNumbers(4, 2, operation: { (a: Int, b: Int) -> Int in
    return a + b
})  
  

  You can reduce the above to the following:
  

  
  
  operateOnNumbers(4, 2, operation: {
    $0 + $1
})  

  There's one more way you can simplify the syntax, but it can only be done 
  when the closure is the final parameter passed to a function
  . In this case, you can move the closure outside of the function call:
  
  
  operateOnNumbers(4, 2) {
    $0 + $1
}  

  
  This is called trailing closure syntax.
  3、The fact that closures can be used to capture variables from the enclosing scope can be extremely useful.
  func countingClosure() -> (() -> Int) {
    var counter = 0
    let incrementCounter: () -> Int = {
        return counter++
    }
    return incrementCounter
}  

  The closure returned from this function will increment its internal counter each time it is called. Each time you call this function you get a different counter.
  For example, this could be used like so:
  
  let counter1 = countingClosure()
let counter2 = countingClosure()

counter1()  // 0
counter2()  // 0
counter1()  // 1
counter1()  // 2
counter2()  // 1

The two counters created by the function are mutually exclusive and count independently. Neat!