当前位置：网站首页>Why do I say: curry = = closure + recursion?

Why do I say: curry = = closure + recursion?

2022-08-07 08:54:00 【InfoQ】

Currying is an indispensable center of gravity in JS elevation, this article will take you to rush it!!

We might as well take the addition of two numbers as an example to explain progressively.

We usually write a function like this to get the value of
adding two numbers
:

function sum(a,b){
console.log(a+b)
}
sum(1,2)

There is nothing wrong with writing this way!

But what?Problems will always arise during development, and the product manager has to add another value. Requirement:
Addition of three numbers
;

We usually comeSay, the first time, just add another parameter directly on the original basis;

So, after the modification, it looks like this:

function sum(a,b,c){
console.log(a+b+c)
}
sum(1,2,3)

Q: Is there anything wrong with writing like this??

Answer: Too bad!

This change violates both: "Open-Closed Principle" and "Single Responsibility Principle".

For those who are not familiar with design principles, please explain briefly:

  • What is the "opening and closing principle"?That is: we should avoid directly modifying functions, classes or modules in our programming, but should expand it on the original basis;
  • whatIs it the "Single Responsibility Principle"?That is: each function, class or module should only be responsible for a single function;

First of all, we modified the parameters and internal calls of the sum function⇒It violates the "opening and closing principle"

Secondly, the sum function is only responsible for adding two numbers. After modification, it is responsible for adding three numbers. The responsibility has changed ⇒ It violates ""Single responsibility principle";

If it is formally written in accordance with the single responsibility, it should be:

// Responsible for adding two numbers
function sum2(a,b){
console.log(a+b)
}

// Responsible for adding three numbers
function sum3(a,b,c){
console.log(a+b+c)
}

In fact, it is impossible to write like this, because if there are ten thousandTo add up the numbers, you have to write 10,000 functions.

and
addition is only one!!
No matter how many values ​​you end up adding, always add one by one.

So, we imagined, can we write a function like this: its function is to "add", with a few parameters, I will add a few.

// is responsible for "addition",
function addCurry(){
...
...
...
}

addCurry(1)(2) // Add two numbers
addCurry(1)(2)(3) // Add three numbers
...
addCurry(1)(2)(3)...(n) //Adding n numbers

Yes, this function is: currying!!(Or this process is called currying, the idea is called currying, Bengua thinks that there is no need to define too much here)

Next, let’s try it step by step, what will it beconstituted?

In order to realize one plus one, that is, the purpose of storing parameters, let's think about it, what magic weapon is there?

Yes, JS profound meaning: closure!

In fact, Ben Gua often thinks, what is the ultimate secret of closure?Finally, understand it as 4 big golden characters:
Delayed processing
!

What does it mean?Briefly explain:

function directHandle(a,b){
console.log("direct processing",a,b)
}

directHandle(111,222)

//Direct handle 111 222

function delayHandle(a){
return function(b){
console.log("DelayHandle",a,b)
}
}

delayHandle(111)

// ƒ (b){
// console.log("delayed processing",a,b)
// }

as above
delayHandle(111)
not like
directHandle(111,222)
prints the value directly, but first return a function
f(b)
; 111 is also temporarily saved,
delayHandle(111)(222)
, you get the same output.That's it: the idea of ​​delayed processing.

Add another sentence: Delayed processing is the essence of functional programming. Under the premise that every function cannot be guaranteed to be a pure function, at the end of pipeline processing, it can maximize theThe degree of assurance reduces side effects.That is, the Monad idea, which will not be expanded here.

Let's get down to business, so we borrowed closures to implement the initial version of currying:

//Add two numbers
function addCurry(a){
return function(b){
console.log(a+b)
}
}

addCurry(1)(2)

// Add three numbers
function addCurry(a){
return function(b){
return function(c){
console.log(a+b+c)
}
}
}

addCurry(1)(2)(3)

The process of writing two closures, you must be smart enough to understand. If you keep writing like this, isn't it recursive?!

So, we know that when there are n parameters, it needs to recurse n-1 times
return function

So, addCurry is written as follows:


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

addCurry(1)(2)(3)()

OK, so far, you're done!!

The above, explained with the simplest code —— Why do I say: Currying == Closure + recursion?

Currying is an idea, and the above addCurry can be said to be the simplest practice.In functional programming, Curry shines even more, such as
compose(fn1)(fn2)(fn3)…(fnN)(args)
and so on.

If someone asks you about currying in the future, you can answer in this direction...

OK, the above is the sharing of this article.If you think it's good, give it a like. Your encouragement, my motivation, insist on original and good quality articles~~ Welcome to comment and leave a message. I am Nuggets Anthony, output exposes input, and technical insight into life.See you soon~~
原网站

版权声明
本文为[InfoQ]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/219/202208070844459084.html

边栏推荐

猜你喜欢

随机推荐