链式编程思想，响应式编程思想，函数式编程思想

链式编程思想

• 思想特点：
  是将多个操作（多行代码）通过点号(.)链接在一起成为一句代码,使代码可读性好。a(1).b(2).c(3)
  方法的返回值是block,block必须有返回值（本身对象），block参数（需要操作的值）
• 代表：
  masonry框架。

<p>模仿masonry写一个计算器</p>

• 表现形式：

  - (void)link{
      int result = [MakeCounet zj_makeCount:^(CountManager *mgn) {
          mgn.add(5).sub(1).muti(6).exp(8);
          }];
   NSLog(@"%d",result);
  }
  

<p>创建一个CountManager，它才是主要进行计算的类所实例化的对象，而不是MakeCounet</p>

• 实现
  + (int)zj_makeCount:(void (^)(CountManager ))code{
  CountManager manager = [CountManager new];
  code(manager);
  return manager.result;
  }
  其中
  mgn.add(5).sub(1).muti(6).exp(8);
  每一步操作都会返回<code> CountManager </code>的实例对象，即实现中得代码所创建的那个<code> manager </code>,具体方法实现如下：
  - (CountManager* (^)(int))add{
  return ^(int number){
  self.result += number;
  return self;
  };
  }
  - (CountManager(^)(int))sub{
  return ^(int number){
  self.result -= number;
  return self;
  };
  }
  - (CountManager(^)(int))muti{
  return ^(int number){
  self.result = number;
  return self;
  };
  }
  - (CountManager(^)(int))exp{
  return ^(int number){
  self.result /= number;
  return self;
  };
  }

响应式编程思想

• 思想特点：
  不需要考虑调用顺序，只需要知道考虑结果，类似于蝴蝶效应，产生一个事件，会影响很多东西，这些事件像流一样的传播出去，然后影响结果，借用面向对象的一句话，万物皆是流。
  是把操作尽量写成一系列嵌套的函数或者方法调用。

• 事例：
  KVO运用。

• 代码：
  - (void)reactive{
  DemoClass* p = [DemoClass new];
  self.p = p;
  [p zj_addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:nil];
  }
  - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
  self.p.name = @"1234";

    }
    - (void)observeValueForKeyPath:(NSString *)keyPath ofObject: (id)object change:(NSDictionary<NSString *,id> *)change context:        (void *)context{
        NSLog(@"发生改变%@",self.p.name);
    }
  

<p>程序运行，现在执行<code> reactive </code>方法，创建<code> DemoClass</code>类的对象，并且通过我们自己写的添加观察者方法添加观察者，观察对象为<code>p</code>的<code>name</code>属性。</p>
<p>在<code>toucheesBegan：</code>方法中，我们改变刚才创建对象<code>p</code>的属性值。</p>
<p>这样在观察者方法中，就可以监听到<code>p</code>的<code>name</code>属性的变化</p>

<code></code>

• 实现过程
  <p>在系统方法中，其实现原理是，在添加观察者时，创建了一个<code>DemoClass</code>的子类<code>NSKVONotifying_DemoClass</code>，并且将<code>p</code>对象的类改成了<code>NSKVONotifying_DemoClass</code></p>

isa：是一个Class 类型的指针. 每个实例对象有个isa的指针,他指向对象的类，而Class里也有个isa的指针, 指向meteClass(元类)。元类保存了类方法的列表。当类方法被调用时，先会从本身查找类方法的实现，如果没有，元类会向他父类查找该方法。同时注意的是：元类（meteClass）也是类，它也是对象。元类也有isa指针,它的isa指针最终指向的是一个根元类(root meteClass).根元类的isa指针指向本身，这样形成了一个封闭的内循环。

<p>改变了isa指针后，访问对象<code>p</code>的<code>name</code>属性则会访问isa指针指向的类的name属性</p>

<p>因此，为了模拟系统的KVO实现，我们也要在自己创建的添加观察者方法调用时，创建一个<code>DemoClass</code>的子类<code>subClass</code>。而且自定义的添加贯彻着方法中我们需要，改变<code>p</code>对象的isa指针，使其指向子类。</p>
- (void)zj_addObserver:(NSObject *)obj forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)option context:(void *)context{
//保存观察对象
objc_setAssociatedObject(self, (__bridge const void *)(observerKey), obj, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
//更改方法监听对象的isa指针,使指针指向他的一个子类
object_setClass(self, [subClass class]);
//子类重写set方法,在set方法中通知观察者
}
<p>子类重写<code>name</code>属性的set方法</p>
- (void)setName:(NSString *)name{
[super setName:name];
//获取观察者对象
id objc = objc_getAssociatedObject(self, observerKey);
//通知外界
[objc observeValueForKeyPath:@"name" ofObject:self change:nil context:nil];

   }

这样通过touchBegan方法改变name的值之后，监听到变化
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
self.p.name = @"1234";

    }
  - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context{
      NSLog(@"发生改变%@",self.p.name);
  }

发生改变1234

函数式编程思想

• 函数式编程本质:
  就是往方法中传入Block,方法中嵌套Block调用，把代码聚合起来管理

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

• 代表：
  ReactiveCocoa(也做函数响应式编程)。

• 代码
  - (void)function2{
  int res= [DoCount doCount1:^int(int result) {
  result += 1;
  result += 2;
  return result;
  }];
  NSLog(@"%d",res);
  }

• 方法内部实现
  + (int)doCount1:(int (^)(int))block{
  int res;
  return block(res);
  }

</br>
</br>
附上代码地址:https://github.com/CodeChanM/ThinkingInPerl