iOS 函数式编程、链式编程

最近看一本书，提到了关于函数式编程和响应式编程，就特地在网上找资料，整理整理，理解理解其差异，就顺带写了这个。

一、函数式编程

首先，要去了解了解block，可以看看这篇文章Objective-C中的block。

1、解释

Functional Programming
函数式编程其实是一种编程思想、编程方式，这个编程思想的重点是在函数上的理解，特别是对函数状态的理解，更深的是函数在Stateless的状态。

2、特性：

函数式编程强调的是纯函数编程，也就是不依赖外部状态，也不改变外部状态。简单的理解就是，函数调用的结果不依赖调用的时间和空间状态；同时，这种函数是线程安全的。

  时间状态：变量一旦有了状态，它就有可能随着时间而发生变化，时间是最不可预知的因素;
  空间状态：如果把一个线程看成一个独立的空间，在程序的世界当中，空间会产生交叉重叠。一个变量如果可以被两个线程同时访问，它的值如果可以在两个空间发生变化，这个变量同样变得很危险。

3 常规关键字

  高阶函数：参数为函数或返回值为函数的函数  //函数式编程就是指这种高度抽象的编程范式
  惰性求值：就是我们常常口语化的“懒加载”，表达式赋值给变量时，并不会马上参与计算求值，是当变量被调用时候才会计算。通过按需加载计算提升性能

其实函数式编程并不会减少我们的代码量，它只是改变的只是我们书写代码的方式而已。这可能需要适应一段时间。

二、链式编程

平时我们经常在项目里使用Masonry，使用的时候大致会这样写：

[self.yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.left.equalTo(self.view).with.offset(10);
    make.top.equalTo(self.view).with.offset(10);
    make.right.equalTo(self.view).with.offset(-10);
    make.bottom.equalTo(self.view).with.offset(-10);
}];

在里面我们看到这样的句子：

make.left.equalTo(self.view).with.offset(10);

通过"."语法，将需要执行的代码连续的书写，就叫做链式编程，它使得代码简单易懂。
现在要实现这种效果，我们举一个例子，由最常见的实现方式，然后逐步修改，最后实现想要的最终效果，比如2-3+4。
想要实现的最后的效果为：

self.add(2).subtract(3).add(4).getResult;

1、最常见的实现

//  TestLinked.h
@interface TestLinked : NSObject
- (void)add:(NSInteger)value;
- (void)subtract:(NSInteger)value;
- (NSInteger)getResult;
@end

//  TestLinked.m
@interface TestLinked ()
@property (nonatomic, assign) NSInteger result;
@end

@implementation TestLinked
/**
    第一种实现方式
*/
- (void)add:(NSInteger)value{
    self.result += value;
}
- (void)subtract:(NSInteger)value{
    self.result -= value;
}
- (NSInteger)getResult{
    return self.result;
}
- (void)testRun_1{
    [self add:2];
    [self subtract:3];
    [self add:4];
    NSInteger result = [self getResult];
    NSLog(@"result = %ld",(long)result);
}
@end

第一种实现就是简单的实现计算，逐步完成。
但是我们想实现函数的这样实现时：add(2)，我们第一反应的是block，因为block的使用时，就是直接用”()“来表示，那么我们可以考虑将函数的返回值改为block，这样就可以实现"()"的使用了，也就贴合我们目的的使用方式了。

2、将函数的返回值全部更换为block

- (void (^)(NSInteger))add;
- (void (^)(NSInteger))subtract;
- (NSInteger)getResult;

具体的实现如下：

/**
 将函数的返回值变成block
 */
- (void (^)(NSInteger))add{
    __weak typeof(self) wself = self;
    void (^addResult)(NSInteger) = ^(NSInteger value){
        wself.result += value;
    };
    return addResult;
}
- (void (^)(NSInteger))subtract{
    __weak typeof(self) wself = self;
    void (^subtractResult)(NSInteger) = ^(NSInteger value){
        wself.result -= value;
    };
    return subtractResult;
}
- (NSInteger)getResult{
    return self.result;
}

- (void)testRun_2{
    //逐步写法
    void (^addBlock)(NSInteger) = self.add;
    void (^subtractBlock)(NSInteger) = self.subtract;
    addBlock(2);
    subtractBlock(3);
    addBlock(4);

    //简写
    self.add(2);
    self.subtract(3);
    self.add(4);

    NSInteger result = [self getResult];
    NSLog(@"result = %ld",(long)result);
}

在调用的地方，写了两种方式的实现，一种是逐步的，一种是直接简写。我们看到了基本的实现。在代码中。我们看到这样一个地方

    self.add(2);
    self.subtract(3);
    self.add(4);

在里面，我们看到每次调用都是用self来发起的，如果想实现这种效果

 self.add(2).subtract(3).add(4);

那么我们需要对self.add(2)这个block提供返回值，而返回值的类型也就是self，即写到的TestLinked类型，这样就可以实现连续的调用。

3、为block添加返回值

- (TestLinked *(^)(NSInteger))add;
- (TestLinked *(^)(NSInteger))subtract;
- (NSInteger)getResult;

/**
 为block添加返回值，返回值类型为TestLinked
 */
- (TestLinked *(^)(NSInteger))add{
    __weak typeof(self) wself = self;
    TestLinked *(^addResult)(NSInteger) = ^(NSInteger value){
        wself.result += value;
        return wself;
    };
    return addResult;
}
- (TestLinked *(^)(NSInteger))subtract{
    __weak typeof(self) wself = self;
    TestLinked *(^subtractResult)(NSInteger) = ^(NSInteger value){
        wself.result -= value;
        return wself;
    };
    return subtractResult;
}
- (NSInteger)getResult{
    return self.result;
}
- (void)testRun_4{
    NSInteger result = self.add(2).subtract(3).add(4).getResult;
    NSLog(@"result = %ld",(long)result);
}

这样就实现了链式的效果。

逐步实现这个过程，其实是一步一步的改变方法的实现，最后满足要求而已。关键里面的使用是block。