011--swift中的闭包

//闭包类似于OC中的block，但是比OC的block应用面更广
/**
    闭包
    1.提前准备好的代码
    2.在需要的时候执行
    3.可以当做参数传递
 */

使用常量记录函数的演练

   //使用常量记录函数的演练
    func demo() {
        print(sum(x: 10, y: 10))
        //1>定义一个常量记录  函数
        // let f: (Int, Int) -> Int
        let f = sum
        let i = 10

        //2>在需要的时候执行
        print(f(20, 20))

    }
    func sum(x: Int,y: Int) -> Int {
        return x + y
    }

---

1>最简单的闭包

//如果没有参数，没有返回值，可以省略，连in都一起省略
        //let b1: () -> ()  没有参数，没有返回值的函数
        let b1 = {
            print("hello")
        }
        //执行闭包
        b1()

---

2>带参数的闭包

     //闭包中，参数返回值实现代码都是写在{}中
        //需要使用一个关键字 `in` 分隔定义和实现
        //{形参列表 -> 返回值类型 // 实现代码}
        //let b2: (Int) -> ()
        let b2 = {(x:Int) -> () in
            print(x)
        }
        b2(100)

        // 3>带参数/返回值的闭包
        //let b3: (Int) -> Int
        let b3 = {
            (x:Int) -> Int in
            return x+250
        }
        print(b3(50))

---

尾随闭包

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
//        loadData { (result) in
//            print(result)
//        }

       //`尾`随闭包
        //如果函数的最后一个参数是闭包，函数参数可以提前结束，最后一个参数直接使用{}包装闭包的代码
        //loadData(completion: <#T##([String]) -> ()#>)
//        loadData { (result) in
//            
//        }
        //按照函数本身编写的结果
        //关于尾随闭包：
        //1、要能看懂
        //2、能够慢慢的编写，大多数Xcode的智能提示会帮我们做
        loadData(completion: { (result)->() in
            print(result)

        })

        }

    }

    func demo() -> (){
        //尾随闭包
        DispatchQueue.global().async { 
            //嵌套的闭包  不会改成尾随闭包
            DispatchQueue.main.async(execute: { 

            })
        }
    }

    /**
        在异步执行任务，获取结果，通过block/闭包  回调
        闭包的应用场景和block完全一致
     */

    func loadData(completion:@escaping (_ result:[String])->()) ->()  {
        //将任务添加到队列，指定执行任务的函数
        //翻译:`队列`调度任务（block/闭包）,以同步/异步的方式执行

        DispatchQueue.global().async {
            print("耗时操作 \(Thread.current)")

            //获取结果
            let json = ["头条","八卦","出大事了"]
            DispatchQueue.main.async(execute: { 
                print("主线程执行UI \(Thread.current)")
                //回调 -> 执行 闭包（通过参数传递的）
                //传递异步获取的结果
                completion(json)
            })
        }
    }


}