函数编程理念

柯里化

柯里化是一种将使用多个参数的一个函数，转换成一系列使用一个参数的函数的技术

前端使用柯里化的主要是简化代码结构，提高系统的维护性，一个方法只有一个参数，强制来功能的单一性， 很自然的做到来功能内聚，降低耦合。柯里化的优点是降低代码的重复，提高代码的适应性。

 function FixedParamsCurry(fn) {
            var _args = Array.prototype.slice.call(arguments, 1)
            return function () {
                var newArgs = _args.concat(Array.prototype.slice.call(arguments, 0))
                return fn.apply(this, newArgs)
            }
        }
        function add(a, b, c, d) {
            return a + b + c + d
        }
        function Curry(fn, length) {
            var argLength = length || fn.length
            return function () {
                if (arguments.length < argLength) {
                    var combined = [fn].concat([].slice.call(arguments, 0))
                    return Curry(FixedParamsCurry.apply(this, combined), argLength - arguments.length)
                } else {
                    return fn.apply(this, arguments)
                }
            }
        }
        var newAdd = Curry(add)
        var result1 = newAdd(1)(2)(3)(4)
        var result2 = newAdd(2,2)(2,3)
        var newAdd1 = newAdd(1); var result3 = newAdd1(2,3,4)

数据处理的扁平化

一个是数组的扁平化，一个是对象的扁平化。其实都是一个降维的过程，既将多层的数组或者对象转化为一层。

	// 数组扁平化
	function flatten(arr) {
		var arr = arr || [],
			result = [],
			len = arr.length;
		for(let i = 0; i < len; i++) {
			if(Array.isArray(arr[i])) {
				result = result.concat(flatten(arr[i]))
			} else {
				result = result.concat(arr[i])
			}
		}
		return result
	}
	// 使用reduce
	const flatten1 = (arr) => arr.reduce((pre, next) => {
		return Array.isArray(next) ? pre.concat(flatten1(next)) : pre.concat(next)
	},[])

惰性函数

判断了一次之后，不需要再去判断第二次。例如下面的添加监听事件的函数。

function addEvent(dom, type, handler) {
	if(dom.addEventListener) {
		dom.addEventListener(type, handler, false)
		addEvent = function (dom, type, handler) { // 重新给这个函数赋值
			dom.addEventListener(type, handler, false)
		}
	} else {
		dom.attachEvent('on' + type, handler)
		addEvent = function (dom, type, handler) { // 重新给这个函数赋值
			dom.attachEvent('on' + type, handler) 
		}
	}
}

函数组合式应用

将其他的函数的功能组合，返回一个新的函数，形成一个新的功能。自右向左执行，将后面的函数执行的结果返回给前面的函数。

function compose() {
	var args = [].slice.call(argument,0)
	var length = args.length - 1
	return function (x) { // 从右向左执行函数
		return args.reduceRight((result, cb) => {
			return cb(result)
		}, x)
	}
}
function a (x) { return x + 'a' }
function b (x) { return x + '!'}
function c (x) { return x.split('')}
var f = compose(a, b, c)
f('a') 

纯函数

对于相同的输入，永远会得到相同的输出，而且没有任何副作用，不影响外部变量，也不依赖外部环境的状态，不依赖不修改外界作用域的变量或状态。

多使用纯函数，可以降低出现bug的概率。

函数记忆

通过闭包，私有化一个 cache 变量，将函数执行的结果缓存到这个 cache 当中。

function mermory (fn) { // 可以通过 mermory 将一个函数包装为一个具有缓存功能的函数
	var cache = {}
	return function () {
		var key = arguments.length + [].join.call(argument) // 使键值唯一
		if(cache[key]) {
			return cache[key]
		} else {
			cache[key] = fn.apply(this, arguments) // 函数执行结果
		}
	}
}