1.ReactiveCocoa简介
ReactiveCocoa（简称为RAC）,是由Github开源的一个应用于iOS和OS开发的新框架,Cocoa是苹果整套框架的简称，因此很多苹果框架喜欢以Cocoa结尾。
2.ReactiveCocoa作用
在我们iOS开发过程中，经常会响应某些事件来处理某些业务逻辑，例如按钮的点击，上下拉刷新，网络请求，属性的变化（通过KVO）或者用户位置的变化（通过CoreLocation）。但是这些事件都用不同的方式来处理，比如action、delegate、KVO、callback等。
其实这些事件，都可以通过RAC处理，ReactiveCocoa为事件提供了很多处理方法，而且利用RAC处理事件很方便，可以把要处理的事情，和监听的事情的代码放在一起，这样非常方便我们管理，就不需要跳到对应的方法里。非常符合我们开发中高聚合，低耦合的思想。
3.编程思想
在开发中我们也不能太依赖于某个框架，否则这个框架不更新了，导致项目后期没办法维护，比如之前Facebook提供的Three20框架，在当时也是神器，但是后来不更新了，也就没什么人用了。因此我感觉学习一个框架，还是有必要了解它的编程思想。
先简单介绍下目前咱们已知的编程思想。
3.1 面向过程：处理事情以过程为核心，一步一步的实现。
3.2 面向对象：万物皆对象
3.3 链式编程思想：是将多个操作（多行代码）通过点号(.)链接在一起成为一句代码,使代码可读性好。a(1).b(2).c(3)
链式编程特点：方法的返回值是block,block必须有返回值（本身对象），block参数（需要操作的值）
代表：masonry框架。
练习一:模仿masonry，写一个加法计算器，练习链式编程思想。
//
// ViewController.m
// 01-链式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "ViewController.h"
#import "NSObject+Calculate.h"
#import "CalculateManager.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
int result = [NSObject kx_makeCalculate:^(CalculateManager * manager) {
// manager.add(5)
// [[manager add:5] add:5];
//用block替代方法
//把怎么计算的代码封装到block中
manager.add(5).add(10);
}];
NSLog(@"%d",result);
}
@end
#pragma mark ------NSObject+Calculate.h文件
// NSObject+Calculate.h
// 01-链式编程思想
//
// Created by 徐流洋 on 2017/5/18.
// Copyright © 2017年 徐sir. All rights reserved.
//
#import <Foundation/Foundation.h>
@class CalculateManager;
@interface NSObject (Calculate)
+ (int )kx_makeCalculate:(void(^)(CalculateManager *manager))block;
@end
#pragma mark -----------------------------------------------
#pragma mark --------NSObject+Calculate.m
// NSObject+Calculate.m
// 01-链式编程思想
//
// Created by 徐流洋 on 2017/5/18.
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "NSObject+Calculate.h"
#import "CalculateManager.h"
@implementation NSObject (Calculate)
+ (int)kx_makeCalculate:(void (^)(CalculateManager *))block{
CalculateManager *manager = [[CalculateManager alloc] init];
block(manager);
return manager.result;
}
@end
#pragma mark -----------------------------------------------
#pragma mark ------ CalculateManager.h
// 01-链式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface CalculateManager : NSObject
/** 计算结果 */
@property (nonatomic , assign) int result;
//-(instancetype)add:(int)value;
//返回值必须是类对象本身
- (CalculateManager *(^)(int))add;
@end
#pragma mark -----------------------------------------------
#pragma mark ------ CalculateManager.m
//
// CalculateManager.m
// 01-链式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "CalculateManager.h"
@implementation CalculateManager
//-(instancetype)add:(int)value{
//
// _result += value;
//
// return self;
//
//}
-(CalculateManager * (^)(int))add{
return ^(int value){
_result += value;
return self;
};
}
@end
#pragma mark -----------------------------------------------
3.4 响应式编程思想：不需要考虑调用顺序，只需要知道考虑结果，类似于蝴蝶效应，产生一个事件，会影响很多东西，这些事件像流一样的传播出去，然后影响结果，借用面向对象的一句话，万物皆是流。
代表：KVO运用。
练习二:KVO底层实现。
KVO底层实现：就是去判断有没有调用一个对象的set方法
1.首先动态创建当前对象类的一个派生类（即：子类）： NSKVONotifying_Person，做KVO
2.修改当前对象的isa指针 -> NSKVONotifying_Person
3.只奥调用对象的set方法，就会调用 NSKVONotifying_Person 的set方法
4.重写 NSKVONotifying_Person 的 set 方法(本质赋值)。
4.1:调用父类赋值[super set:];
4.2:通知观察者，告诉你属性改变
KVO底层实现的过程
#pragma mark -------- ViewController.m
// ViewController.m
// 02-响应式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "ViewController.h"
#import "Person.h"
#import "NSObject+KVO.h"
@interface ViewController ()
/**
*
*/
@property (nonatomic , strong) Person *person;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
Person *person = [[Person alloc] init];
_person = person;
//给person添加观察者
[person kx_addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:nil];
//1.只要 person 的 age 属性一改变，就会调用观察者的 observeValueForKeyPath
//KVO底层实现：
//1.首先动态创建当前对象类的一个派生类（即：子类）： NSKVONotifying_Person，做KVO
//2.修改当前对象的isa指针 -> NSKVONotifying_Person
//3.只奥调用对象的set方法，就会调用 NSKVONotifying_Person 的set方法
//4.重写 NSKVONotifying_Person 的 set 方法(本质赋值)。
//4.1:调用父类赋值[super set:];
//4.2:通知观察者，告诉你属性改变
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
_person.age++;
}
//只要person.name的值已改变就会调用
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
NSLog(@"%d",_person.age);
}
#pragma mark -----------------------------------------------
#pragma mark ----------Person.h
// Person.h
// 02 - 响应式编程思想
// Copyright © 2017年 徐sir. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Person : NSObject
/** age */
@property (nonatomic , assign) int age;
@end
#pragma mark -----------------------------------------------
#pragma mark ----------NSObject+KVO.h
// NSObject+KVO.h
// 02-响应式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
#import <Foundation/Foundation.h>
@interface NSObject (KVO)
- (void)kx_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context;
@end
#pragma mark -----------------------------------------------
#pragma mark ----------NSObject+KVO.m
//
// NSObject+KVO.m
// 02-响应式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "NSObject+KVO.h"
#import <objc/message.h>
#import "KXKVONotifying_Person.h"
NSString * const observerKey = @"observer";
@implementation NSObject (KVO)
-(void)kx_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context{
/**
KVO底层实现：
1.首先动态创建当前对象类的一个派生类（即：子类）： KXKVONotifying_Person，做KVO
2.修改当前对象的isa指针 -> KXKVONotifying_Person
3.只奥调用对象的set方法，就会调用 KXKVONotifying_Person 的set方法
4.重写 KXKVONotifying_Person 的 set 方法(本质赋值)。
4.1:调用父类赋值[super set:];
4.2:通知观察者，告诉你属性改变
*/
//本质;就是修改当前对象的isa指针的类名
//self：kx_addObserver方法的调用者即：person
object_setClass(self, [KXKVONotifying_Person class]);
//把观察者保存到当前对象里(动态添加属性)
/**
<#id object#>:给那个对象添加关联
<#const void *key#>：属性名
<#id value#>：关联值
<#objc_AssociationPolicy policy#>：策略：是assign,retian...
*/
objc_setAssociatedObject(self, (__bridge const void *)(observerKey), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
@end
#pragma mark -----------------------------------------------
#pragma mark ----------KXKVONotifying_Person.m
// KXKVONotifying_Person.m
// 02-响应式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "KXKVONotifying_Person.h"
#import <objc/message.h>
extern NSString *const observerKey;
@implementation KXKVONotifying_Person
- (void)setAge:(int)age{
[super setAge:age];
//通知观察者，属性改变
id observer = objc_getAssociatedObject(self, observerKey);
// 调用观察者的方法
[observer observeValueForKeyPath:@"age" ofObject:self change:nil context:nil];
}
@end
#pragma mark -----------------------------------------------
3.5 函数式编程思想：是把操作尽量写成一系列嵌套的函数或者方法调用。
函数式编程本质:就是往方法中传入Block,方法中嵌套Block调用，把代码聚合起来管理
函数式编程特点：每个方法必须有返回值（本身对象）,把函数或者Block当做参数,block参数（需要操作的值）block返回值（操作结果）
代表：ReactiveCocoa。
练习三:用函数式编程实现，写一个加法计算器,并且加法计算器自带判断是否等于某个值.
#pragma mark -----------ViewController.m
// ViewController.m
// 03-函数式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
/**
* 函数式编程思想:把一个操作写成一系列方法
* 需求：写一个加法计算器，并且加法计算器自带判断是否等于某个值
*/
#import "ViewController.h"
#import "Caculator.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
Caculator *caculator = [[Caculator alloc] init];
//10 + 20 + 29
// [[[caculator add:10] add:20] add:29];
BOOL isEqule = [[[caculator add:^int(int result) {
//把计算的事情写到block
result += 10;
result += 30;
result += 20;
result += 40;
return result;
}] equle:^BOOL(int result) {
// 判断结果是否 等于 100
return result ==100;
}] isEqule];
NSLog(@"%d",isEqule);
}
@end
#pragma mark -------------------------------
#pragma mark ----------- Caculator.h
//
// Caculator.h
// 03-函数式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Caculator : NSObject
/** 计算结果 */
@property (nonatomic , assign) int result;
@property (nonatomic , assign) BOOL isEqule;
//- (instancetype)add:(int)num;
- (instancetype)add:(int(^)(int result))block;
- (instancetype)equle:(BOOL(^)(int result))block;
@end
#pragma mark -------------------------------
#pragma mark ---------- Caculator.m
//
// Caculator.m
// 03-函数式编程思想
//
// Copyright © 2017年 徐sir. All rights reserved.
//
#import "Caculator.h"
@implementation Caculator
//- (instancetype)add:(int)num{
//
//
// _result += num;
//
// return self;
//
//
//}
- (instancetype)add:(int (^)(int result))block{
_result = block(_result);
return self;
}
- (instancetype)equle:(BOOL (^)(int))block{
_isEqule = block(_result);
return self;
}
@end
#pragma mark -------------------------------
4.ReactiveCocoa编程思想
ReactiveCocoa结合了几种编程风格：
函数式编程（Functional Programming）
响应式编程（Reactive Programming）
所以，你可能听说过ReactiveCocoa被描述为函数响应式编程（FRP）框架。
以后使用RAC解决问题，就不需要考虑调用顺序，直接考虑结果，把每一次操作都写成一系列嵌套的方法中，使代码高聚合，方便管理。
