函数式编程 — 柯里化

柯里化编程函数

作用：参数复用、提前返回、延迟执行
概念：是把接受多个参数的函数变成接受一个单一参数的函数，并且返回接受余下的参数而且返回结构的新函数的技术；

普通函数

// 一次传递多个参数
functiont add(x, y, z) {   
	return x+y+z
}
const add = (x, y, z) => x+y+z

柯里化函数

// 柯里化函数是志传递函数一部分参数来调用它，让它返回一个函数去处理剩下的参数。
// 普通函数
const add = (x)=>{
	return function(y){
		return function	(z){
			return x + y + z
		}
	}
}
 // 箭头函数：
const add = x=>y=>z=>x+y+z

// 使用柯里化函数（单次传入参数）
cosnt fun1 = add(11)
const fun2 = fun1(22)
const value = fun2(33)
console.log( value )  // 66
（一次性传入参数）
add(11)(22)(33)  // 66

1、参数复用

// 普通函数，每次要传两个参数
function check(reg, txt) {
	return reg.test(txt)
}

check(/\d+/g, 'test')       //false
check(/[a-z]+/g, 'test')    //true

// 柯里化函数
function curry(reg) {
	return function( txt ) {
		return reg.test(txt)
	}
}
var hasNumber = curry(/\d+/g)   
hasNumber('test1')      		// true
hasNumber('testtest')  			 // false

var hasLetter = curry(/[a-z]+/g)
hasLetter('21212')      		// false
hasLetter('testtest')   		// true

2、提前返回

//把isSupport这个参数给先确定下来了,自执行然后返回一个新的函数，这样其实就是提前确定了会走哪一个方法，避免每次都进行判断

var on = function(isSupport, element, event, handler) {
	 isSupport = isSupport || document.addEventListener;
	 if (isSupport) {
	      return element.addEventListener(event, handler, false);
	 } else {
	      return element.attachEvent('on' + event, handler);
	 }
}

3、延迟调用

// 我们js中经常使用的bind，实现的机制就是Curry
Function.prototype.bind = function (context) {
	 var _this = this
	  var args = Array.prototype.slice.call(arguments, 1)
	 
	  return function() {
	      return _this.apply(context, args)
	 }
}

柯里化函数封装使用

function curry(fn, args) {
	 var length = fn.length;
	 var args = args || [];
	 return function(){
	     newArgs = args.concat(Array.prototype.slice.call(arguments));
	     if(newArgs.length < length){
	          return curry.call(this,fn,newArgs);
	     }else{
	         return fn.apply(this,newArgs);
	     }
	 }
}
	
function multiFn(a, b, c) {
	 return a + b + c;
}
	
var multi = curry(multiFn);
multi(2)(3)(4);  // 9
multi(2,3,4); 	// 9
multi(2)(3,4);  // 9
multi(2,3)(4);  // 9