链式编程思想-函数式变成思想计算器

编程思想

先简单介绍下目前已知的编程思想。

面向过程:处理事情以过程为核心,一步一步的实现。

面向对象:万物皆对象

链式编程思想:是将多个操作(多行代码)通过点号(.)链接在一起成为一句代码,使代码可读性好。a(1).b(2).c(3)

  • 链式编程特点 : 方法的返回值是block,block必须有返回值(本身对象),block参数(需要操作的值)

  • 代表 : Masonry

响应式编程思想 : 不需要考虑调用顺序,只需要知道考虑结果,类似于蝴蝶效应,产生一个事件,会影响很多东西,这些事件像流一样的传播出去,然后影响结果,借用面向对象的一句话,万物皆是流。

  • 代表 :KVO

函数式编程思想 是把操作尽量写成一系列嵌套的函数或者方法调用

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

  • 代表 : ReactiveCocoa

-

链式编程思想

1>一般开发习惯把事情封装到一个方法中;链式编程思想是把要做的事情封装到block中,给外部提供一个返回这个block的方法

2>链式编程思想方法特点:方法的返回值必须是block,block的参数是需要操作的内容,block的返回值是返回这个block的方法的调用者

1 尝试设计成类方法

1.1不知道方法的返回值 就返回void
img

add方法无法连续调用,所以add方法必须返回 CalculateMaker类

1.2 方法返回值是类本身

需要把累加的结果保存起来,但是类方法不能使用属性,使用static 静态全局变量

img

2 设计成对象方法

add方法要连续调用,add方法就要返回CalculateMaker类的对象实例

CalculateMaker.h

1
2
3
4
5
6
#import <Foundation/Foundation.h>

@interface CalculateMaker : NSObject
@property (nonatomic,assign) int result;
- (instancetype)add:(int)num;
@end

CalculateMaker.m

1
2
3
4
5
6
7
8
#import "CalculateMaker.h"

@implementation CalculateMaker
- (instancetype)add:(int)num{
_result += num;
return self;
}
@end
实现:
1
2
3
4
5
6

CalculateMaker *maker = [[CalculateMaker alloc] init];
int result = [[[[maker add:10] add:10] add:10] result];
NSLog(@"result = %d",result);

//CalculateMaker[8230:1471099] result = 30

3.链式编程的可读性 返回值是block类型

1
maker.add(10).add(20).add(30).add(40)
只有返回值是block才能实现该效果
##### 3.1 add方法返回值是block,block类型无参数无返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//.h
//返回值block,block类型无参数无返回值
- (void(^)())add;


//.m
- (void (^)())add{
return ^{
NSLog(@"返回一个block,该block无参数无返回值");
};
}


//implementation
CalculateMaker *maker = [[CalculateMaker alloc] init];
maker.add();

//CalculateMaker[10247:1491527] 返回一个block,该block无参数无返回值

CalculateMaker类的实例有一个add方法,调用add方法返回值是一个block,外部拿到这个block可以block();执行里面封装的代码

计算的操作在block中完成,外部不需要知道block的实现细节,外部只是调用执行该block即可

3.2 add方法返回值是block, block类型有参数(int)无返回值
1
2
3
4
5
6
7
8
9
10
11
12
13

- (void(^)(int num))add;

- (void (^)(int))add{
return ^(int num){
NSLog(@"add方法返回一个block,该block有int参数无返回值");
};
}

CalculateMaker *maker = [[CalculateMaker alloc] init];
maker.add(10);

// CalculateMaker[11045:1497617] add方法返回一个block,该block有int参数无返回值

链式编程思想 : 把业务逻辑的实现封装在block,把block返回到外部执行
如何连续执行add方法,让这个block执行完毕返回CalculateMaker类的对象实例即可

3.3add方法返回值是block, block类型有参数(int)有返回值(类的对象实例)
1
2
3
4
5
6
7
8
9
10
11
12

- (instancetype (^)(int num))add;

- (instancetype (^)(int))add{
return ^(int num){
NSLog(@"add方法返回一个block,该block有int参数有返回值是类的对象实例");
return self;
};
}

CalculateMaker *maker = [[CalculateMaker alloc] init];
maker.add(10).add(20);

img

不能使用instancetype
1
2
3
4
5
6
7
8
9
10
11
12

- (CalculateMaker* (^)(int num))add;

- (CalculateMaker* (^)(int))add{
return ^(int num){
NSLog(@"add方法返回一个block,该block有int参数有返回值是类的对象实例");
return self;
};
}

CalculateMaker *maker = [[CalculateMaker alloc] init];
maker.add(10).add(20);
4. 所有的NSObject都能计算 分类

让所有的OC的类都能计算,给所有的类分类出一个方法,把实现计算的操作聚合在一个block代码块中

CalculateMaker.h

1
2
3
4
5
6
7
8
9

#import <Foundation/Foundation.h>

@interface CalculateMaker : NSObject

@property (nonatomic,assign) int result;
- (CalculateMaker* (^)(int num))add;

@end

CalculateMaker.m

1
2
3
4
5
6
7
8
9
10
11
12
#import "CalculateMaker.h"

@implementation CalculateMaker

- (CalculateMaker* (^)(int))add{
return ^(int num){
_result += num;
return self;
};
}

@end

NSObject+Calculate.h

1
2
3
4
5
6
#import <Foundation/Foundation.h>
#import "CalculateMaker.h"

@interface NSObject (Calculate)
+ (int)makeCalculate:(void (^) (CalculateMaker *))block;
@end

NSObject+Calculate.m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#import "NSObject+Calculate.h"

@implementation NSObject (Calculate)

+(int)makeCalculate:(void (^)(CalculateMaker *))block{
// 计算制造者
CalculateMaker *maker = [[CalculateMaker alloc] init];
// 执行计算
block(maker);
// 返回计算结果
return maker.result;
}

@end
1
2
3
4
5
6
7
8
//implementation

int result = [NSObject makeCalculate:^(CalculateMaker *maker) {
maker.add(1).add(2).add(3);
maker.add(4).add(5).add(6);
}];

NSLog(@"result = %d",result);

-

函数式编程思想

  • 函数式编程思想 : 是把操作尽量写成一系列嵌套的函数或者方法调用
  • 函数式编程本质 : 就是往方法中传入Block,方法中嵌套Block调用,把代码聚合起来管理

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

实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//.h
@property (nonatomic, assign) int result;
- (instancetype)PH_calculate:(int(^)(int))calculateBlock;


//.m
- (instancetype)PH_calculate:(int (^)(int))calculateBlock
{
_result = calculateBlock(_result);
return self;
}


//implementation

PHCalculateManager *calculateManager = [[PHCalculateManager alloc] init];

int result = [[calculateManager PH_calculate:^int(int result) {
// 存放所有的计算代码
result += 8;
result *= 8;
result -= 4;
result /= 3;
return result;
}] result];
NSLog(@"%d",result);

}

# iOS

Comments

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×