函数式编程

发表于 | 分类于 |

函数式编程思想：是把操作尽量写成一系列嵌套的函数或者方法调用。
函数式编程特点：每个方法必须有返回值（本身对象）,把函数或者Block当做参数,block参数（需要操作的值）block返回值（操作结果）

需求:写一个加法计算器,并且加法计算器自带判断是否等于某个值.
1、创建计算机对象，封装对应的需求实现方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@interface Caculator : NSObject
@property (nonatomic, assign) int result;
@property (nonatomic, assign) BOOL isEqule;
- (instancetype)add:(int(^)(int result))block;
- (instancetype)equle:(BOOL(^)(int result))block;
@end
@implementation Caculator
- (instancetype)add:(int (^)(int result))block
{
    _result = block(_result);
    return self;
}
- (instancetype)equle:(BOOL (^)(int))block
{
    _isEqule = block(_result);
    return self;
}
@end

2、外部调用，把一个操作写成一系列的方法

1
2
3
4
5
6
7
8
9
10
11
12
Caculator *caculator = [[Caculator alloc] init];
BOOL isEqule = [[[caculator add:^(int result){
        result += 10;
        result += 20;
        result += 30;
        result += 40;
        return result;
    }] equle:^BOOL(int result) {
        return result == 100;
    }] isEqule];
    
    NSLog(@"%d",isEqule);

Swift的函数式编程

一.函数可以像 Int 或者 String 那样被赋值给变量，也可以作为另一个函数的输入参数，或者另一个函数的返回值来使用
二. 函数能够捕获存在于其局部作用域之外的变量
三. 有两种方法可以创建函数，一种是使用 func 关键字，另一种是 { }。在 Swift 中，后一种被称为闭包表达式

1、把函数赋值给变量

1
2
3
4
5
func printInt(i: Int) {
    print("you passed \(i)")
}
let funVar = printInt
funVar(2) //you passed 2

2、把函数作为另一个函数的参数

1
2
3
4
5
func useFunction(function: (Int) -> () ){
    function(3)
}
useFunction(function: printInt) // you passed 3
useFunction(function: funVar) // you passed 3

3、把函数作为另一个函数的返回值

1
2
3
4
5
6
7
8
func returnFunc() -> (Int) -> String{
    func innerFunc(i:Int) -> String{
        return "you passed\(i)"
    }
    return innerFunc
}
let myFunc = returnFunc()
myFunc(4)

4、函数可以捕获存在于它们作用范围之外的变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func counterFunc() -> (Int) -> String {
    var counter = 0
    func innerFunc(i: Int ) -> String {
        counter += i // counter is captured
        return "running total: \(counter)"
    }
    return innerFunc
}
let f = counterFunc()
f(3) // running total: 3
f(4) // running total: 7
let g = counterFunc()
g(2) // running total: 2
g(2) // runningtotal: 4

innerFunc捕获了counter变量属性
一个函数和它所捕获的变量环境组合起来被称为闭包
上面 f 和 g 都是闭包的 例子，因为它们捕获并使用了一个在它们外部声明的非局部变量 counter。

闭包

闭包指的是一个函数以及被它所捕获的所有变量的组合。而使用{ } 来创建的函数被称为闭包表达式
可以把闭包表达式理解为匿名的函数，可以理解为把闭包赋值给了以函数名为名的变量
闭包的优点：简洁，像是 map 这样的将一个快速实现的函数传递给另一个函数时，这个特点更为明显
如果函数的最后一个参数是闭包表达式的话，你可以将这个闭包表达式移到函数调用的 圆括号的外部。这样的尾随闭包语法
如果一个函数除了闭包表达式外没有别的参数，那么方法名后面的调用时的圆括 号也可以一并省略。

1、使用func定义函数

1
2
3
4
func doubler(i: Int) -> Int {
    return i * 2
}
[1, 2, 3, 4].map(doubler) // [2, 4, 6, 8]

2、使用闭包表达式的语法来写相同的函数，像之前那样将它传给 map:

1
2
let doublerAlt = { (i: Int) -> Int in return i*2 }
[1, 2, 3, 4].map(doublerAlt) // [2, 4, 6, 8]

3、使用Swift 中的一些特性，来让代码更加简洁

1
[1, 2, 3].map{$0*2 } // [2, 4, 6]

打赏支持一下呗！