链式编程思想

什么是链式编程？
顾名思义，链式编程是通过一行代码，实现某种功能。这里比较经典的案例就是masonry框架，相信对于我们来说都不陌生。类似于这种效果：

 make.top.equalTo(self.view).offset(60)

是可以通过(.)实现某种效果的。
而通过”点”语法，将需要执行的代码块连续的书写下去,就是链式编程.它能使代码可读性强，书写方便，简单解藕。

链式编程尝试

下面我们来尝试一下用链式编程，实现一个计算器的功能
创建一个MannerResultModel管理类和NSObject+sum.h分类，其中，MannerResultModel是对result结果的管理

MannerResultModel.h 
#import <Foundation/Foundation.h>
@interface MannerResultModel : NSObject
//计算结果
@property(assign,nonatomic)int result;

// 调用带参数的方法
//-(instancetype)add:(int)value;

// 调用无参数的block
//-(void(^)(int value))add;

//调用有参数，并且有返回值block
-(MannerResultModel *(^)(int value))add;
-(MannerResultModel *(^)(int value))reduce;
-(MannerResultModel *(^)(int value))multiply;
-(MannerResultModel *(^)(int value))divide;

@end

MannerResultModel.m
#import "MannerResultModel.h"

@implementation MannerResultModel
// 加
-(MannerResultModel * (^)(int value))add{
    __weak typeof(self)weakSelf = self;
    return ^(int value){
        weakSelf.result += value;
        return self;
    };
}
// 减
-(MannerResultModel * (^)(int value))reduce{
    __weak typeof(self)weakSelf = self;
    return ^(int value){
        weakSelf.result -= value;
        return self;
    };
}
// 乘
-(MannerResultModel * (^)(int value))multiply{
    __weak typeof(self)weakSelf = self;
    return ^(int value){
        weakSelf.result *= value;
        return self;
    };
}
// 除
-(MannerResultModel * (^)(int value))divide{
    __weak typeof(self)weakSelf = self;
    return ^(int value){
        weakSelf.result /= value;
        return self;
    };
}

NSObject+sum.h类
#import <Foundation/Foundation.h>
#import "MannerResultModel.h"
@interface NSObject (sum)
+ (int)lc_makeContraints:(void(^)(MannerResultModel *))sumBlock;
@end

NSObject+sum.m类
#import "NSObject+sum.h"
@implementation NSObject (sum)
+ (int)lc_makeContraints:(void (^)(MannerResultModel *))sumBlock{
    MannerResultModel * mgr = [[MannerResultModel alloc]init];
    sumBlock(mgr);
    return mgr.result;
}
@end

尝试一：用带参数的返回本身的方法回调
结果：实现的是[]调用效果，不能够实现链式效果

int result = [NSString lc_makeContraints:^(MannerResultModel *mar) {
        MannerResultModel *manner = [mar add:111];
     }];
NSLog(@"result====%d",result);

尝试二：用不带参数的block的方法回调
结果：实现的第一个可以使用（.）语法，因为没有返回值，所以不能再调用其它方法
*/不能够实现链式效果
int result = [NSString lc_makeContraints:^(MannerResultModel *mar) {
mar.add(100);
}];
NSLog(@"result====%d",result);

尝试三：有参数的block ，返回对象本身
尝试结果：用‘( )’实现函数式编程 + ‘ . ’形成链式编程（带参）,用block实现

int result = [NSString lc_makeContraints:^(MannerResultModel *msg) {
    msg.add(100).reduce(99).multiply(2).divide(2);
}];
NSLog(@"result====%d",result);

尝试结果：实现了类似于masonry的链式效果，good！
最后总结：

msg.add(100).reduce(99).multiply(2).divide(2);

所谓的这种链式编程，实际上是把block作为一个返回值，并且是返回一个对象，再次进行点语法时，依然调用方法，然后返回一个对象，所以可以一直进行方法操作，实现某种功能。

原理

原理就是调用的属性的类型或者方法的返回类型为原调用属性的类型
例如说UILabel调用了某个方法或者属性，得到的类型还是UILabel，那么还可以继续调用UILabel的属性或者方法

明白了吗？明白了吗？
END