链式编程

链式编程

实现一个类似于 Masonry 的链式编程，加法。

第一步

我们需要一个返回值是 Int 的方法，入参应该是一个匿名函数，也就是Block 。

#import <Foundation/Foundation.h>
@class CaculatorMaker;

@interface NSObject (Caculator)

//计算
+ (int)makeCaculators:(block)someBlock;

@end

这样，我们就可以实现这样的结构。

int result = [NSObject makeCaculators:^() {
        
}];

第二步

block 的结构。
这个 block 作为函数的参数，不需要什么返回值，但是需要一个贯穿始终的类作为参数，我们定义这个类为CaculatorMaker，block 为void (^)(CaculatorMaker *maker)

#import <Foundation/Foundation.h>
@class CaculatorMaker;

@interface NSObject (Caculator)

//计算
+ (int)makeCaculators:(void (^)(CaculatorMaker *maker))caculatorMaker;

@end

第三步

这个类需要一个整形属性@property (assign, nonatomic) int result;。在上面函数的实现中，返回这个属性，且把这个类传入 block 中。

+ (int)makeCaculators:(void (^)(CaculatorMaker *))caculatorMaker
{
    CaculatorMaker *maker = [[CaculatorMaker alloc] init];
    caculatorMaker(maker);
    return maker.result;
}

第四步

这个类需要加减乘除等算法，这个算法必须返回之前我们定义的类才可以继续反复调用，所以方法为

- (CaculatorMaker *)add:(int)value
{
    _result += value;
    return self;
}

调用为：

int result = [NSObject makeCaculators:^(CaculatorMaker *maker) {
    [[[maker add:1] add:2] add:3];
}];

第五步

但是这并不是点语法，等号右侧点语法实际是取相关 get 方法，不能有参数，所以要包装一下。返回一个 block，在 block 里再返回这个类，在 block 里传入这个 int 值。

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

调用

int result = [NSObject makeCaculators:^(CaculatorMaker *maker) {
    maker.add(1).add(2).add(3);
}];

补充两点：
CaculatorMaker 类中 result 没设定值，所以创建时默认为0，在 makeCaculators 方法中没有重新初始化，不断叠加
maker.add(1) 完整写法其实如下
CaculatorMaker *(^block) (int value) = [maker add];
block(1);

函数式编程

实现一个类似于 rac 的函数式编程，计算输入数值结果，并与某数值比较是否相等。

第一步

我们需要一个类贯穿始终，拥有属性 result 记录当前值，isEqual 判断是否相等，caculator 方法进行计算。
caculate 方法需要返回一个 caculator 类，需要一个 block 作为参数。

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

//计算
- (Caculator *)caculate:(block)caculatorBlock;

实现如下格式：

c = [c caculate:^(block)) {
}];

第二步

分析 block 的内容，需要一个 int 入参作为初始值，一个 int 出参作为运算结果。

- (Caculator *)caculate:(int(^)(int result))caculatorBlock
{
    _result = caculatorBlock(_result);
    return self;
}  

逻辑可以放到 block 里直接进行。

c = [c caculate:^int(int result) {
    result += 2;
    result *= 5;
    return result;
}];

第三步

后续逻辑类似

- (Caculator *)equal:(BOOL (^)(int))operationBlock
{
    _isEqual = operationBlock(_result);
    return self;
}

使用

Caculator *c = [[Caculator alloc] init];
c = [[c caculate:^int(int result) {
    result += 2;
    result *= 5;
    return result;
}] equal:^BOOL(int result) {
    return result == 10;
}];

第四步

获取类中属性。

BOOL result = [[[c caculate:^int(int result) {
    result += 3;
    result *= 4;
    return result;
}] equal:^BOOL(int result) {
    return result == 12;
}] isEqual];

响应式编程的概念

在网上流传一个非常经典的解释｀响应式编程的概念｀
在程序开发中：
a ＝ b ＋ c
赋值之后 b 或者 c 的值变化后，a 的值不会跟着变化
响应式编程，目标就是，如果 b 或者 c 的数值发生变化，a 的数值会同时发生变化；