Function coritization

currying

In mathematics and Computer Science , Currierization is a technique that transforms a function with multiple parameters into a series of functions with one parameter .

in other words , When a function has multiple parameters, it is called by passing some parameters （ These parameters will never change in the future ）, Then it returns a new function to receive the remaining parameters , Return results , This is the currification of functions .

function checkAge(min){
    
    return function(age){
    
        return age >= nim;
    }
}

effect

The main purpose of front-end using Coriolis is to simplify the code structure , Improve the maintainability of the system , One way , There is only one parameter , It enforces the unity of function , It's natural to achieve functional cohesion , To reduce the coupling . The advantage of physics and chemistry is to reduce the repetition of code , Improve the adaptability of code

Call mode

function add(a,b,c){
    }; 
var newAdd = Curry(add);   // After being processed by Coriolis function add function 
newAdd(1)(2)(3)
newAdd(1,2)(3);

function curry (func) {
     
	//  Get the number of formal parameters of the function , Can pass   Function name .length 
	// args  Indicates the actual parameters passed in 
	//  Take the famous function here , Not anonymous functions , Because when the number of arguments and formal parameters are the same , You need to call this function 
    return function curriedFn (...args) {
     // ES6 grammar 
        //  Determine the number of actual and formal parameters 
        if (args.length < func.length) {
     
        	//  When the passed in parameter   add   The remaining parameters , Equal to the number of formal parameters , Execute the following code 
            return function () {
      //  When getting this call , Incoming parameter 
                return curriedFn(...args.concat(Array.from(arguments))) 
            } 
        }
        //  When the number of arguments is greater than or equal to the number of formal parameters , call  func, Return results  
        return func(...args) // ES6 grammar  ...  Expand the array 
    } 
} 

//  Functions to be coriolised  
function getSum (a, b, c) {
     
    return a + b + c 
}

let curried = curry(getSum) 

//  test  
// (args.length = 3) = func.length, Call directly func,  Return results 
curried(1, 2, 3) 
// 1. (args.length = 1) < func.length ,  Executing anonymous functions , call curriedFn, Pass in the parameter 2, here  args.length = 2
// 2. (args.length = 2) < func.length,  Executing anonymous functions , call curriedFn, Pass in the parameter 3, here  args.length = 3
// 3. (args.length = 3) = func.length, Call directly func,  Return results 
curried(1)(2)(3) 
// 1. (args.length = 2) < func.length ,  Executing anonymous functions , call curriedFn, Pass in the parameter 3, here  args.length = 3
// 2. (args.length = 3) = func.length, Call directly func,  Return results 
curried(1, 2)(3)