链式编程、函数式编程

一.链式编程

定义：是将多个操作(多行代码)通过点号"."链接在一起成为一句代码。

核心：声明一个Block的属性；这个block返回值必须还是一个对象（根据业务需求不同，可以返回的是这个对象实例本身，也可以是这个类的另一个实例，更可以是另一个类的实例对象）。

二.函数式编程

定义：把操作尽量写成一系列嵌套的函数或者方法调用。

核心：每个方法必须返回值是本身对象，把函数或者block当做参数。

Block参数：（需要操作的值）
Block返回值：（操作结果）

补充：
合成：如果一个值要经过多个函数，才能变成另外一个值，就可以把所有中间步骤合并成一个函数，这叫做函数的合成
柯里化：柯里化，就是把一个多参数的函数，转化为单参数函数

类型	作手点	特点
链式编程	属性	声明一个block属性, block返回值必须还是一个对象
函数式编程	方法	每个方法必须返回值是本身对象，把函数或者block当做参数。

链式编程示例

//
//  CalculatorMaker.swift
//  链式编程示例
//
//  Created by apple on 2018/11/27.
//  Copyright © 2018 apple. All rights reserved.
//

import UIKit

class CalculatorMaker: NSObject {
    var result : Int = 0
    
    func add(num : Int)-> CalculatorMaker {
        result += num
        return self
    }
    
    func sub(num : Int)-> CalculatorMaker {
        result -= num
        return self
    }
    
}

class Calculator {
    static func beginCalculator( calculatorBlock:(CalculatorMaker)->()) -> Int {
        let calculator = CalculatorMaker()
        calculatorBlock(calculator)
        return calculator.result
    }
}

let result = Calculator.beginCalculator { (calculator) in
            _ = calculator.add(num: 1).sub(num: 2)
        }
        
        print("result-----\(result)")

函数式编程示例

//
//  Caculator.swift
//  函数式编程示例
//
//  Created by apple on 2018/11/27.
//  Copyright © 2018 apple. All rights reserved.
//

import UIKit

class Caculator: NSObject {

    var result:Int = 0
    var isEqule:Bool = false
    
    
    /// 加法运算
    ///
    /// - Parameter operation: 参数`operation` block, result 操作的值， block 返回值即是操作结果
    /// - Returns: 返回 `Caculator` 对象
    func add(operation: (_ result:Int) -> Int) -> Caculator {
        result = operation(result)
        return self
    }
    
    /// 减法运算
    ///
    /// - Parameter operation: 参数`operation` block, result 操作的值， block 返回值即是操作结果
    /// - Returns: 返回 `Caculator` 对象
    func minus(operation: (_ result:Int) -> Int) -> Caculator {
        result = operation(result)
        return self
    }
    
    /// 乘法运算
    ///
    /// - Parameter operation: 参数`operation` block, result 操作的值， block 返回值即是操作结果
    /// - Returns: 返回 `Caculator` 对象
    func multiply(operation: (_ result:Int) -> Int) -> Caculator {
        result = operation(result)
        return self
    }
    
    /// 除法运算
    ///
    /// - Parameter operation: 参数`operation` block, result 操作的值， block 返回值即是操作结果
    /// - Returns: 返回 `Caculator` 对象
    func divide(operation: (_ result:Int) -> Int) -> Caculator {
        guard result != 0 else {
            result = 0
            return self
        }
        result = operation(result)
        return self
    }
    
    
    func isEqual(operation: (_ result:Int) -> Bool) -> Caculator {
        isEqule = operation(result)
        return self
    }
    
}

// 什么是函数式编程思想：把一个操作写成一系列的方法
        // 需求：写一个计算器，并且计算器的结果是否等于100
       let isEqule = Caculator.init().add { (result) -> Int in
            print("return:\(result)")
            return result + 100
        }.multiply { (number1) -> Int in
                return number1 * 100
        }.isEqual { (result) -> Bool in
                return result == 110
        }.isEqule
    
        print("result-----\(isEqule)")