函数柯里化

柯里化是把接受多个参数的函数变换成接受一个单一参数的函数,并返回接受余下参数而且返回结果的新函数。

例如:

//原函数
function sum(a,b){
	return a+b
}
sum(1,2)
//改写结果
//1.定义接收一个参数的函数
function sum(a){
//2.内部返回一个接收剩余参数的新函数,返回累加结果
	return function(b){
		return a+b
	}
}
//该写sum可以实现如下效果
sum(1)(2)

function sum(a,b,c){
	return a+b+c
}
sum(1,2,3)//6

//该写结果
function sum(a){
  return function(b){
	return function(c){
	  return a+b+c
	}
  }
}
sum(1)(2)(3) //6

面试题

function sum(a,b,c,d,e){
    return a+b+c+d+e
}
//改写函数sum实现,参数传递到5个即可实现累加
//sum(1)(2)(3)(4)(5)
//sum(1)(2,3)(4)(5)
//sum(1)(2,3,4)(5)
//sum(1,2,3)(4,5)

//1.保存不定长参数
let nums=[]
function sum(...args) {
    nums.push(...args)
    //2.判断参数个数
    if(nums.length>=5){
        //2.1长度到5累加
        nums.slice(0,5).reduce((p,v)=>p+v,0)
        //累加之后需要清空数组,保证下次累加的值是正确的
        nums=[]
        return res
    }else{
    //2.2长度没到5返回函数接收剩余参数
        return sum
    }
}

为了使代码变得更加通用,我们需要将参数的个数可以自定义

function sumMaker(length){
	let nums=[]
	function sum(...args){
		nums.push(...args)
		if(nums.length>=length){
			const res=nums.slice(0,length).reduce((p,v)=>p+v,0)
			nums=[]
			return res
		}else{
			return sum
		}
	}
  return sum
}

实际应用.例如判断参数是什么类型

function isUndefind(thing){
    return typeof thing === 'undefined'
}

function isNumber(thing){
    return typeof thing === 'Number'
}

function isString(thing){
    return typeof thing === 'String'
}

function isFunction(thing){
    return typeof thing === 'function'
}

//改变通过typeOfTest生成
const typeofTest=function(type){
    function isUndefind(thing){
        return typeof thing === type
    }
    return isUndefind
}
//最简写法 
const typeofTest=type=>thing=>typeof thing===type