swift3.0闭包使用

//
//  ViewController.swift
//  函数和闭包
//
//  Created by mibo02 on 17/1/5.
//  Copyright © 2017年 mibo02. All rights reserved.
//

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //调用
        let string:String =
        greet(person: "fengfeng", day: "11号")
        print(string)
        
        let string1 =
        somesthing(on: "xiaoming", "12号")
        print(string1)
        
        let string2 = newOtherSthing(scores: [5,3,100,3,9])
        print(string2.sum)
        print(string2.2)
        let sumOF1 =
        sumOF(numbers: 50,80,90)
        print(sumOF1)
        
        print(calAdd(100,150))
        
        testFunction {
            print("去掉括号的尾随闭包写法")
        }
        
        
    }
    //函数
    //使用func 声明一个函数。通过函数名称和参数调用一个函数。使用->区分参数名和函数返回的类型。
    func greet(person:String,day:String) -> String {
        return "Hello \(person), today is \(day)"
    }
    //函数的参数可以有外部参数名和内部参数名，外部参数名标记函数传入的参数，内部参数名在函数实现的地方使用。_表示没有外边参数名。
    func somesthing(on person:String, _ day:String) -> String {
        return "hell0 \(person), today is \(day)"
    }
    //一个函数需要返回多个值可以使用元组。元组中的元素可以使用名称和下标访问。
    func newOtherSthing(scores:[Int]) -> (min:Int,max:Int,sum:Int) {
        var min = scores[0]
        var max = scores[0]
        var sum = 0
        for score in scores {
            if score > max {
                max = score
            } else if score < min {
                min = score
            }
            sum += score
        }
        
        return (min,max,sum)
        
    }
    //函数也可以有可变数量的参数，将这个参数看成是一个数组。
    //一个可变参数可以接受零个或多个值 ...
    func sumOF(numbers:Int...) -> Int {
        var sum = 0
        for number in numbers {
            sum += number
        }
        return sum
    }
    
    //函数可以被嵌套。里面的嵌套函数可以访问外面函数的变量。你可以在一个函数中使用嵌套函数是这个函数变得更长更复杂。
    func returnFifteen() -> Int {
        var y = 10
        func add() {
            y += 5
        }
        add()
        return y
        
    }
    //  一个函数也可以用其他函数作为参数。
    func hasAnyMatches(list:[Int],condition:(Int)->Bool) -> Bool {
        for item in list {
            if condition(item) {
                return true
            }
        }
        return false
    }
    //闭包
    let calAdd:(Int,Int)->(Int) = {
        (a:Int,b:Int) -> Int in
        return a + b
    }
    //或者Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
    let callAdd2 :(Int,Int)->(Int) = {
        a,b in
        return a + b
    }
    //单行表达式闭包可以隐式返回，如下，省略return
    let callAdd3:(Int,Int)->(Int) = {(a,b) in a + b}
    
    //如果闭包没有参数，可以直接省略“in”
    let callAdd4:()->Int = {return 100 + 200}
    //
    let callAdd5:()->Void = {print("这是一个什么也没有的函数")}
    //起别名
    typealias addBlock = (Int,Int)->(Int)
    
    let Add:addBlock = {
        (c, d) in
        return c + d
    }
    //尾随闭包
   // 若将闭包作为函数最后一个参数，可以省略参数标签,然后将闭包表达式写在函数调用括号后面
    func testFunction(testBlock:()->Void) {
        //这里需要传进来的闭包类型是无参数和无返回值的
        testBlock()
    }
    //函数嵌套形式
    //返回的是一个函数，()->Int类型的函数
    func camtureValue(amount:Int) -> ()->Int {
        var total = 0
        //函数
        func incrementer()->Int {
            total += amount
            return total
        }
        return incrementer
        
    }
    //闭包形式
    func captureValue2(sums amount:Int) -> () ->Int {
        var total = 0
        //闭包
        let addNewBlock:()->Int = {
            total += amount
            return total
        }
        return addNewBlock
      
    }
    //逃逸闭包
    //当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。
    func doSomething(some: @escaping () -> Void) {
        //延时操作，注意这里的单位是秒
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1, execute: {
            //一秒后操作
            some(print("我是一秒之后才执行的"))
        })
        print("函数体")
    }
    
    //
    var comletionHandle: ()->String = {"约吗？"}
    func doSomething2(some: @escaping ()->String) {
        comletionHandle = some
    }
    
    var completionHandlers:[() -> Void] = []
    //逃逸
    func someFunctionWithEscapingClosure(completionHandler: @escaping() -> Void) {
        completionHandlers.append(completionHandler)
    }
    
    
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }


}

//参考http://www.jianshu.com/p/c0e43b13cc7a