浅谈闭包

• 闭包就是一段代码块，可以在任何地方调用。和函数类似，有参数和返回值。

<!--通用的语法定义闭包，它接受参数并有返回类型 -->
{(参数) -> 返回类型 in
}

• 来看一个简单的例子

let printClourse = {
    print("欢迎来到闭包")
}

printClourse()

• 带有参数的闭包

let add = { (num1: Int, num2: Int) -> Int in
    return num1 + num2
}
print(add(3,3))

• 我们现在能像声明变量一样声明一个闭包，并且能调用它了。那我们想一下变量能当做参数在函数之间传递，那闭包是否可以呐，我们来看一下苹果那些函数中使用闭包当做参数传递的。sorted(by: <(Int, Int) -> Bool>)里需要一个闭包一样的参数。

let datas = [8,9,2,3,1]
let sortedClourse = { (argc1: Int, argc2: Int) -> Bool in
    return argc1 < argc2
}
let sortedDatas1 = datas.sorted(by: sortedClourse)
print(sortedDatas1)

• 当然我们也可以这样去写

let sortedDatas2 = datas.sorted { (argc1, argc2) -> Bool in
    return argc1 < argc2
}
print(sortedDatas2)

• 如果你感觉这样写你感觉还比较麻烦，你还可以这样写

let sortedDatas3 = datas.sorted(by: {return $0 < $1})
print(sortedDatas3)

• 还可以更简单

let sortedDatas4 = datas.sorted(by: {$0 < $1})
print(sortedDatas4)

• 最简单

let sortedDatas5 = datas.sorted(by: <)
print(sortedDatas5)

下面让我们来更好的认识闭包吧

• 声明闭包

<!--声明一个闭包Void相当于()-->

let i: Int //声明一个变量
let clourse: (_ argc1: Int) -> Void 

• 定义一个闭包

<!--定义一个闭包-->
i = 3 //定义一个变量
clourse = { argc1 in
    print(argc1)
} 

• 调用

print(i) //调用一个变量
clourse(5) //调用一个闭包

实战吧骚年

• 实现一个简单计算器，支持加减乘除

typealias CalculatorOperationType = (Int , Int) -> (Int)

let addOperation: CalculatorOperationType = { (num1, num2) -> Int in
        return num1 + num2
}

let minusOperation: CalculatorOperationType = { (num1, num2) -> Int in
    return num1 - num2
}
let multiplyOperation: CalculatorOperationType = { (num1, num2) -> Int in
    return num1 * num2
}

let divideOperation: CalculatorOperationType = { (num1, num2) -> Int in
    if num2 == 0 {
        return 0
    }
    return num1/num2
}

• 来试试我们的计算器可以工作不

addOperation(5, 6)
minusOperation(1, 2)
multiplyOperation(2, 5)
divideOperation(6, 2)

• 换个姿势试试看

let minusOperationStrong: CalculatorOperationType = (-)
let multiplyOperationStrong: CalculatorOperationType = {$0*$1}

minusOperationStrong(5, 2)

• 闭包当做函数参数

func calculatorOperationFactor(calculatorOperation: CalculatorOperationType) -> Int {
    return calculatorOperation(5, 6)
}

calculatorOperationFactor(calculatorOperation: add)
calculatorOperationFactor(calculatorOperation: minusOperationStrong)

calculatorOperationFactor { (argc1, arc2) -> (Int) in
    return (argc1 + 5) * arc2
}

• 闭包当做返回类型

func calculatorTwoNumers(calculatorType: String) -> CalculatorOperationType? {
    if calculatorType == "+" {
        return add
    } else if calculatorType == "-" {
        return minusOperation
    } else if calculatorType == "*" {
        return { (argc1, argc2) -> Int in //这里是为了让你加深闭包到底是什么
            return argc1 * argc2
        }
    } else if calculatorType == "/" {
        return (/)
    }
    return nil
}

let calculator = calculatorTwoNumers(calculatorType: "-")
calculator!(5,3)

• 接着进行思考我们写了这么多代码，有没有好一点的方法实现这个简单的计算器哪！写一个方法将要操作的数据和操作传过去，就出一个结果。想想sorted是如何做的

func calculatorTwoNumberByOperationType(num1: Int, num2: Int, operationType: CalculatorOperationType) -> Int {
    return operationType(num1, num2)
}

calculatorTwoNumberByOperationType(num1: 5, num2: 6, operationType: (+))

接下来我们会更加深入了解闭包，请先了解逃逸闭包，非逃逸闭包，自动闭包的一些概念吧
下节传送门