函数式编程之柯里化

1.柯里化可以把函数作为参数传递给另一个函数,可以实现闭包或者惰性计算;

1.首先请看最简单的例子：

// 普通的add函数
function add(x, y) {
    return x + y
}

// Currying后
function curryingAdd(x) {
    return function (y) {
        return x + y
    }
}

add(1, 2)           // 3
curryingAdd(1)(2)   // 3
//换种写法
var dome=curryingAdd(2);
dome(1)//3
dome(3)//5
dome(1)(2)//报错
//思考：
//为什么会出现这样的现象？
//从闭包角度解释这一现象

2.上面的例子的柯里化，局限性很大,是根据函数功能单独写的，那如何写一个通用的柯里化函数

一. 函数式编程的特点就式可以用函数作为一个参数

二.从上面的例子可以看出用个变量的存储 返回出来的值 var dome=curryingAdd(2) 等于 function (y) {return 2 + y}

function cuury(fn, agrs) {
	//fn是cuury本身调用函数   agrs为回调参数  不为 外部调用使用  也就是说与fn无关
	var length = fn.length;
	var agrs = agrs || [];
	//var agrs=Array.prototype.slice.call(arguments,1)
	return function() {
		//这边做缓存 newAgrs  arguments为cuury调用函数的参数
		var newAgrs = agrs.concat(Array.prototype.slice.call(arguments));
		if(newAgrs.length < length) {
             //递归 将参数以及闭包下的fn 调用
			return cuury.call(this, fn, newAgrs)
		} else {
            //递归出口 并且执行函数
			return fn.apply(this, newAgrs)
		}
	}
}

function add(x, y , z) {
    return x + y + z;
}
var dome=cuury(add);
//dome 这边也就等于cuury返回的函数并且因为闭包 将 length,以及agrs的变量存储下来
dome(1)//f()...递归中
dome(2)//f()...递归中
dome(3)//6 递归出口  并执行函数

个人观点总结：柯里化 原理 利用函数闭包性质存储 参数 以及  return新的匿名函数  （它里面参数  就是调用函数的参数 ）分开处理 然后延迟执行；

3. 扩展：

function curry(){
		  	var agrs=Array.prototype.slice.call(arguments);
		  	var fn=function(){
		  		var newargs=agrs.concat(Array.prototype.slice.call(arguments));
		  		display.apply(this,newargs)
		  	}
		  	fn.toString=function(){
		  		return agrs.reduce(function(a,b){
		  			return a+b;
		  		})
		  	}
		  	return fn;
}
curry(1) //f 1
curry(2) //f 3
curry(3) //f 6
//思考 为什么会有这样的结果