最近看一本书，提到了关于函数式编程和响应式编程，就特地在网上找资料，整理整理，理解理解其差异，就顺带写了这个。
一、函数式编程
首先，要去了解了解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。
