Handwriting Currying - toString Comprehension

Currying can be achieved by closure + recursion

let arr = []
function addCurry() {
let arg = Array.prototype.slice.call(arguments); // Collect parameters
arr = arr.concat(arg);
if (arg.length === 0) { //If the parameter is empty, judge the end of the recursion
return arr.reduce((a,b)=>{return a+b}) // Summation
} else {
return addCurry;
}
}

addCurry(1)(2)(3)() // 6


There is nothing wrong with writing like this, through:

Array.prototype.slice.call(arguments)

The parameters are collected and pushed to

arr

In the

array; when there are parameters, recursively call, when there are no parameters, use

reduce()

Summation and return;

But if you write it like this, there will be external variables arr. If arr is not cleaned up, it will be saved all the time, resulting in continuous calling errors:

addCurry(1)(2)(3)() // 6
addCurry(1)() // 7


So, it needs to be rewritten like this:

function addCurry() {
let arr = [...arguments]
let fn = function () {
if(arguments.length === 0) {
return arr.reduce((a, b) => a + b)
} else {
arr.push(...arguments)
return fn
}
}
return fn
}


Add another layer of arr to the function. Every time it is called, it will be re-declared, and the original value will be cleaned up;

The idea of ​​adding before is still not enoughChange;

But in doing so, there is still a problem: it always needs to end with empty brackets () to judge the end of the call;

Can it be removed?This, can be evaluated directly as follows:

addCurry(1)(2)(3)

//or

addCurry(1)(2,3)


The answer is yes, the principle is to use

toString

, when the value of Function is used for calculation, toString will be called for implicit conversion;

let fn = function(){}

fn.toString = () => 1

fn == 1 // true


So, our code is updated to:

function addCurry() {

let arr = [...arguments]

// Use closures to collect all parameter values
varfn = function() {
arr.push(...arguments);
return fn;
};

//Using toString implicit conversion
fn.toString = function () {
return arr.reduce(function (a, b) {
return a + b;
});
}
return fn;
}

addCurry(1)(2)(3) == 6 // true


must be hereNote that directly printing addCurry(1)(2)(3) cannot get the value, and only when it is implicitly converted can it be calculated correctly.

Summary:

In fact, no matter whether you use empty brackets () as the basis for "starting reduce addition", or use the implicit conversion of toString to doBy the way, there is always a criterion to tell the curried function: you can execute it!

The essence of currying is parameter collection and delayed execution!

Delay is the essence of JS function closure design!!

OK, the above is the sharing of this article.Like, follow and comment to help the good article

I am Nuggets Anthony 1 million readings Popular front-end technology blogger INFP Writing personality Perseverance 1000 days of updates to spend a long time with youYears