【JavaScript进阶之旅 函数式编程篇 第三十四章】函数组合、结合律、pointfree、使用案例

一、函数组合

• 函数组合：又叫饲养函数 compose

若干个纯函数、偏函数、柯里化函数组成一个新的函数，形成数据传递，并实现一种有序执行的效果

function toUpperCase(str) {
	return str.toUpperCase();
}

function exclaim(str) {
	return str + '!';
}

console.log(exclaim(toUpperCase('hello'))); // HELLO!
1
2
3
4
5
6
7
8
9

1、左倾（高阶函数的左倾）

上述例子很明显不易读，我们可以使用高阶函数中的左倾来优化

• 左倾：一个函数内部传入了一个参数，这个参数是函数的执行，那么这个函数一定是左倾的

	function toUpperCase(str) {
		return str.toUpperCase();
	}

	function exclaim(str) {
		return str + '!';
	}

	// 组合函数 compose
	function compose(f, g) {
		// x是通过f g之间的'管道'来传输值
		return function(x) { // 为了compose函数不直接执行f函数
			return f(g(x)); // 这句话的执行方式是：左倾（函数的参数里执行了一个函数，这就叫做左倾）一个函数内部传入了一个参数，这个参数是函数执行，那么这个函数一定是左倾的
		}
	}

	var f = compose(exclaim, toUpperCase);
	console.log(f('hello')); // HELLO!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2、 组合多个函数

方法一（使用while）

	function toUpperCase(str) {
		return str.toUpperCase();
	}

	function exclaim(str) {
		return str + '!';
	}

	function split(str) {
		return str.split('');
	}

	function reverse(str) {
		return str.reverse();
	}

	function join(str) {
		return str.join('-');
	}

	function compose2() {
		// 将类数组arguments转换为数组
		var args = Array.prototype.slice.call(arguments),
				len = args.length - 1;

		return function(x) {
			// 执行最后一个函数
			var res = args[len](x);

			while(len --) {
				res = args[len](res);
			}

			return res;
		}

	}

	var f2 = compose2(join, reverse, split, exclaim, toUpperCase);
	console.log(f2('hello')); // !-O-L-L-E-H
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
30
31
32
33
34
35
36
37
38
39
40

方法二：优化组合函数（使用reduceRight）

	function compose2() {
		var args = Array.prototype.slice.call(arguments);

		return function(x) {
			return args.reduceRight(function(res, cb) {
				return cb(res);
			}, x);
		}
	}

	var f2 = compose2(join, reverse, split, exclaim, toUpperCase);
	console.log(f2('hello')); // !-O-L-L-E-H
1
2
3
4
5
6
7
8
9
10
11
12

二、结合律

• 结合律：Associativity

	function split(str) {
		return str.split('');
	}

	function reverse(str) {
		return str.reverse();
	}

	function join(str) {
		return str.join('-');
	}

	function compose2() {
		var args = Array.prototype.slice.call(arguments);

		return function(x) {
			return args.reduceRight(function(prev, cur) {
				return cur(prev);
			}, x);
		}
	}

	var f = compose2(join,  reverse, split);
	var f1 = compose2(compose2(join, reverse), split)
	var f2 = compose2(join, compose2(reverse, split));

	console.log(f('hello')); // o-l-l-e-h
	console.log(f1('hello')); // o-l-l-e-h
	console.log(f2('hello')); // o-l-l-e-h

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
30

• 组合律：在组合参数compose中的参数在进行分组，任何的结合，都不会影响结果，他是一种规律

三、pointfree

Love means never having to say you’re sorry. (我觉得爱不需要说抱歉)
Excuse me.

Pointfree style means never having to say your data.(这种格式从不需要说自己的数据)