JavaScript笔记：柯里化，数据扁平化，惰性函数

柯里化

在数学和计算机科学中，柯里化是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。
前端使用柯里化主要是为了简化代码结构。提高系统的可维护性，一个方法，只有一个参数，强制了功能的单一性，使其功能内聚，降低了耦合。

function curry(fn, length){
	var length = length || fn.length;
	return function(){
		if(arguments.length < length){
			var combined = [fn].concat([].slice.call(arguments,0));
			return curry(fixedParmaCurry.apply(this, combined), length - arguments.length)
		}else{
			return fn.apply(this,arguments);
		}
	}
}
function fixedParmaCurry(fn){
	var args = [].slice.call(arguments,1);
	return function(){
		var newArg =args.concat([].slice.call(arguments,0));
		return fn.apply(this, newArg);
	}
}
function add(a, b, c, d){
	return a + b + c +d;
}
	var newAdd = curry(add);
	var n1 = newAdd(1);
	var n2 = n1(2);
	console.log(n2(3, 4));
	var a = fixedParmaCurry(add, 1,2);//function(){return fn.apply}
	console.log(a(3, 4));//add.apply(this,newArg)

扁平化

var arr = [[2,3], 'haha',45,6, ['a', 'b', 'c'], 'hi', {name: 'jane'}];
function flatten(arr){
	var arr = arr || [];
	var res = [];
	for(var i = 0, len = arr.length; i < len; i++){
		Object.prototype.toString.call(arr[i]) == '[object Array]'? (res = res.concat(flattern(arr[i]))) : res.push(arr[i]);
	}
	return res;
}
// console.log(flatten(arr));
Array.prototype.flatten = function(){
	var resArr = [];
	this.forEach(function(item){
		Object.prototype.toString.call(item) == '[object Array]'? resArr = resArr.concat(item.flatten()) : resArr.push(item);
	})
	return resArr;
}
console.log(arr.flatten());

惰性函数

惰性载入表示函数执行的分支只会在函数第一次掉用的时候执行，在第一次调用过程中，该函数会被覆盖为另一个按照合适方式执行的函数，这样任何对原函数的调用就不用再经过执行的分支了。
针对于优化频繁使用的函数。

function addEvent(dom, type, handler){
	if(dom.addEventListener){
		dom.addEventListener(type, handler, false);
		addEvent = function(dom, type, handler){
			dom.addEventListener(type, ,alse);
		}
	}else{
		dom.attachEvent('on' + type, handler);
		addEvent = function(dom, type, handler){
			dom.attachEvent('on' + type, handler); 
		}
	}
}