一、链式编程思想、响应式编程思想和函数式编程

1. 链式编程思想

链式编程思想的核心就是方法的返回值必须是Block，Masonry是链式编程思想应用的代表。

1.1 Masonry应用链式编程思想详解

    UIView *redView = [[UIView alloc] init];
    redView.backgroundColor = [UIColor redColor];
    [self.view addSubview:redView];

    /**
     给控件设置布局,把控件的所有约束保存到约束制造者中.

     1.创建一个约束制造者
     2.调用block(maker),把所有的控件的约束全部保存到约束制造者
     3.[constraintMaker install]:遍历约束制造者的所有约束给控件添加约束
     
     @param make 约束制造者
     @return MASConstraint
     */
    [redView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.top.equalTo(@10);
        make.right.bottom.equalTo(@(-10));
    }];

1.2 链式编程思想应用---计算器

@interface CaculatorMaker : NSObject

@property (nonatomic, assign) int result;

- (instancetype)add:(int)num; 

- (CaculatorMaker *(^)(int num))add;
- (CaculatorMaker *(^)(int))sub;
- (CaculatorMaker *(^)(int num))multy;
- (CaculatorMaker *(^)(int))divide;

@end

@implementation CaculatorMaker

- (instancetype)add:(int)num
{
    _result += num;
    return self;
}

- (CaculatorMaker * (^)(int num))add
{
    return ^(int num){
        _result += num;
        return self;
    };
}

@end

#import <Foundation/Foundation.h>
#import "CaculatorMaker.h"

@interface NSObject (Caculator)

// 以后计算都使用这个方法,一调用这个方法就返回结果.
+ (int)makeCaculator:(void(^)(CaculatorMaker *))block;

@end

#import "NSObject+Caculator.h"
#import "CaculatorMaker.h"

@implementation NSObject (Caculator)
+ (int)makeCaculator:(void (^)(CaculatorMaker *))block
{
    // 创建计算制造者
    CaculatorMaker *maker = [[CaculatorMaker alloc] init];
    // 计算
    block(maker);
    
    return maker.result;
}
@end

    // 1.创建计算制造者
    CaculatorMaker *maker = [[CaculatorMaker alloc] init];
    
    // 提供一个没参数的add方法,返回值block
    int reslut1 = [[[[[maker add:10] add:20] add:30] add:40] result];
    
    // block:使代码高聚合
    int result2 = [NSObject makeCaculator:^(CaculatorMaker *maker) {
        // 把所有的计算代码封装到这里
        maker.add(10).add(20);
        maker.multy(3);
    }];
    
    NSLog(@"%d",result2);

之前开发中比较习惯把事情封装到一个方法中,链式编程思想:把要做的事情封装到block,给外界提供一个返回这个Block的方法。

链式编程思想方法特点:

方法返回值必须是block
block参数:放需要操作的内容
block返回值:方法调用者

2. 响应式编程思想

不需要考虑调用顺序，只需要知道考虑结果，类似于蝴蝶效应，产生一个事件，会影响很多东西，这些事件像流一样的传播出去，然后影响结果，借用面向对象的一句话，万物皆是流。代表有KVO的运用。

模仿系统提供的KVO：

@interface Person : NSObject
{
    @public
    int _age;
}
@property (nonatomic, assign) int age;

@end

@implementation Person

@end

@interface LLKVONotifying_Person : Person

@end

#import "LLKVONotifying_Person.h"
#import <objc/runtime.h>

@implementation LLKVONotifying_Person
- (void)setAge:(int)age
{
    [super setAge:age];
    
    // 通知观察者,属性改变
    id observer = objc_getAssociatedObject(self, @"observer");
    
    [observer observeValueForKeyPath:@"age" ofObject:self change:nil context:nil];
}
@end

@interface NSObject (KVO)

- (void)LL_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context;

@end

#import "NSObject+KVO.h"
#import "LLKVONotifying_Person.h"
#import <objc/runtime.h>

@implementation NSObject (KVO)
- (void)LL_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context
{
    // 1.动态创建NSKVONotifying_Person,NSKVONotifying_Person是Person子类,做KVO
    // 2.修改当前对象的isa指针->NSKVONotifying_Person
    // 3.只要调用对象的set,就会调用NSKVONotifying_Person的set方法
    // 4.重写NSKVONotifying_Person的set方法,1.[super set:] 2.通知观察者,告诉你属性改变
    
    // 修改isa,本质就是改变当前对象的类名
    object_setClass(self, [LLKVONotifying_Person class]);
    
    // 把观察者保存到当前对象里
    
    // 添加关联
    // id object:给哪个对象添加关联属性
    // key:属性名
    // value:关联值
    objc_setAssociatedObject(self, @"observer", observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
@end

@interface ViewController ()

@property (nonatomic, strong) Person *p;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *p = [[Person alloc] init];
    _p = p;

    // 添加观察者
    //[p addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:nil];
    [p LL_addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:nil];
}

// 监听的属性只要一改变就调用
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context
{
    NSLog(@"%d",_p.age);
}

KVO底层实现:

1.动态创建NSKVONotifying_Person,NSKVONotifying_Person是Person子类,做KVO
2.修改当前对象的isa指针->NSKVONotifying_Person
3.只要调用对象的set,就会调用NSKVONotifying_Person的set方法
4.重写NSKVONotifying_Person的set方法,1.[super set:] 2.通知观察者,告诉你属性改变

KVO的实质就是去判断有没有调用一个对象的set方法。

3. 函数式编程思想

其实就是把操作尽量写成一系列嵌套的函数或者方法调用。

特点：每个方法必须有返回值（本身对象）,把函数或者Block当做参数,block参数（需要操作的值）block返回值（操作结果）

利用函数式编程写一个加法计算器,并且加法计算器自带判断是否等于某个值。

@interface Caculator : NSObject

@property (nonatomic, assign) int result;
@property (nonatomic, assign) BOOL isEqule;

- (instancetype)add:(int(^)(int result))block;
- (instancetype)equle:(BOOL(^)(int result))block;

@end


@implementation Caculator
- (instancetype)add:(int (^)(int result))block
{
    _result = block(_result);
    
    return self;
}

- (instancetype)equle:(BOOL (^)(int))block
{
    _isEqule = block(_result);
    
    return self;
}
@end

    Caculator *caculator = [[Caculator alloc] init];
    BOOL isEqule = [[[caculator add:^(int result){
        // 把计算的事情写到Block
        
        result += 10;
        result += 20;
        result += 30;
        result += 40;
        
        return result;
        
    }] equle:^BOOL(int result) {
        
        return result == 100;
    }] isEqule];

函数式编程的代表是：ReactiveCocoa，在下一篇中我们会详细讨论ReactiveCocoa。