Swift3.0 之闭包(Closures)详解和传值

参考swift3.0 文档 :http://www.swift51.com/swift3.0/chapter2/07_Closures.html

闭包 :是自包含的函数代码块，可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的匿名函数比较相似。

闭包可以捕获和存储其所在上下文中任意常量和变量的引用。闭合、包裹常量和变量，所谓闭包也。Swift 会为你管理在捕获过程中涉及到的所有内存操作。

Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下
-利用上下文推断参数和返回值类型
-隐式返回单表达式闭包，即单表达式闭包可以省略return 关键字
-参数名称缩写
-尾随（Trailing）闭包语法

实践出真理！上代码

    let arry = [1,2,3,4]
    var newArry = [Int]()
     /*下面的闭包表达式示例使用 sorted(by:) 方法对一个 Int 类型的数组进行大小排序。 (by: 方法) 我们使用闭包的形式来展示*/

        //标准闭包
        newArry = arry.sorted(by: { (s1:Int ,s2 :Int) -> Bool in
            return s1 > s2
        })

        //1.根据上下文推断类型（Inferring Type From Context）
        //推测类型 参数类型省略:.sorted(by: <#T##(Int, Int) -> Bool#>)
        newArry = arry.sorted(by: {s1 , s2 in return s1 > s2 })
        
        //2.单表达式闭包隐式返回（Implicit Returns From Single-Expression Closures）
        //单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
        newArry = arry.sorted(by: {s1 , s2 in s1 > s2})
        
        //3.参数名称缩写（Shorthand Argument Names）
        //如果你在闭包表达式中使用参数名称缩写，你可以在闭包定义中省略参数列表，并且对应参数名称缩写的类型会通过函数类型进行推断。in关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
        newArry = arry.sorted(by: {$0 > $1})
        
        //4.运算符方法（Operator Methods）
        //运算符本身也是一种函数
        newArry = arry.sorted(by: >)

-- 尾随闭包（Trailing Closures) - 先声明一个函数

    func someTrailing(_ closure: @escaping () ->Bool) ->Void {
        //参数为 closure: @escaping () ->Void 闭包的函数
        //函数体部分
        _ = closure
        print( "someTrailing:" + String(describing: closure))
    }

        //5. 尾随闭包（Trailing Closures)
        //如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签：

        //不使用尾随
        someTrailing( {() -> Bool in return 1 < 2 } )
        
        //使用尾随
        someTrailing { () -> Bool in
            return 1 < 2
        }
        //或
        someTrailing{
            return 1 < 2
        }
        
         //************
        //例如：map(_:) 为数组中每一个元素调用了一次闭包表达式。
        /* 闭包放入map括号后 尾随
        (number) -> String in
        let outPut = "\(number)"
        return outPut  
          */
        let strings = arry.map {
            (number) -> String in

            let outPut = "\(number)"
    
            return outPut
           }
        print( "strings:\(strings)")

-- 回调传值 ,与OC中Block相似

第一个VC

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

    let secondViewController = SecondViewController()
        
        secondViewController.someClosures{ (arry) in
            
            print("arr: \(arry)")
            
        }

    self.present(secondViewController, animated: true, completion: nil)
}

第二个VC

import UIKit

class SecondViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
            
        }

     //Closures类似Block
     func someClosures(_ Closures :( _ a :NSArray) -> Void) {
        //函数部分
        
        //回调
         Closures([1,2,3])
      }
        // Do any additional setup after loading the view.
    }

打印：

Snip20161123_2.png