JavaScript function currying is a technique that converts functions that accept multiple parameters into a series of functions that accept a single parameter. This technique allows us to create reusable functions more easily, and also allows us to perform function combinations and functional programming more easily.
The principle of currying is achieved through closures. When we call a Curry function, it returns a new function that remembers the parameters passed in before and waits for the next parameter to be received. When all parameters are passed in, the new function executes the original function and returns the result.
The main usage scenarios of Curry
- Parameter multiplexing: Curry can split a function into multiple functions, each function only receives one parameter, which can easily multiplex parameters and reduce code redundancy.
- Delayed execution: Currying can delay the execution of a function until later, so that functions can be executed when needed, improving the performance of the code.
- Partial applications: Curry can pass some parameters of a function first and return a new function. This new function can receive the remaining parameters, which can facilitate partial applications and reduce code redundancy.
- Function combination: Curry can combine multiple functions to form a new function. This new function can receive multiple parameters, which can easily combine functions and reduce code redundancy.
1. Parameter reuse
Function Currying is a technique of converting multiple parameters into a series of single-parameter functions. This technique allows us to reuse functions more easily, and also allows us to combine functions more easily.
In Currying, we can break down multiple parameters of a function into multiple single-parameter functions and then combine these single-parameter functions to be called when needed.
The advantage of this is that we can save these single-parameter functions for reusing when needed.
For example, we can transform a function that accepts two parameters into two functions that accept a single parameter:
function add(x, y) {
return x + y;
}
function curryAdd(x) {
return function(y) {
return add(x, y);
}
}
var add5 = curryAdd(5);
(add5(3)); // 8
(add5(7)); // 12
In the example above, we willaddThe function Curry is transformed intocurryAddfunction, which accepts an argumentx, and return a function that accepts an argumentyand returnadd(x, y)The result.
We can usecurryAddFunction to create a new functionadd5, the function willxSet as5, and can be called when needed.
This technique allows us to more conveniently reuse functions. For example, we can use currying to create a general function that can take any number of parameters and add them:
function add() {
var args = (arguments);
var sum = (function(acc, val) {
return acc + val;
}, 0);
return sum;
}
function curry(fn) {
return function curried() {
var args = (arguments);
if ( >= ) {
return (null, args);
} else {
return function() {
var moreArgs = (arguments);
return (null, (moreArgs));
};
}
};
}
var curriedAdd = curry(add);
(curriedAdd(1)(2)(3)(4)(5)); // 15
(curriedAdd(1, 2)(3, 4)(5)); // 15
(curriedAdd(1, 2, 3, 4, 5)); // 15
In the example above, we usecurryFunction toaddFunction Currying.
This function accepts a functionfn, and return a new function that can take any number of parameters and pass them tofnfunction.
If the number of parameters passed is reachedfnThe number of parameters of the function is called directlyfnfunction and return result.
Otherwise, a new function is returned, which merges the previously passed parameters with the newly passed parameters and continues to wait for the next call.
Using currying allows us to reuse functions more easily and allows us to combine functions more easily.
For example, we could use currying to create a general function that can take any number of functions and combine them:
function compose() {
var fns = (arguments);
return function(x) {
return (function(acc, fn) {
return fn(acc);
}, x);
}
}
function add1(x) {
return x + 1;
}
function double(x) {
return x * 2;
}
var add1AndDouble = compose(double, add1);
(add1AndDouble(5)); // 12
In the example above, we usecomposeFunction toadd1anddoubleCombine functions.
This function accepts any number of functions and returns a new function that can accept a parameterx, and pass it to all functions, then combine their results.
In this example, we willadd1anddoubleCombine the functions and useadd1AndDoubleVariable to save this new function.
We can useadd1AndDoubleFunction to add one number and multiply two.
2. Delayed execution
In Currying, we can use delayed execution to achieve more flexible function combinations.
Delayed execution is to delay the execution of a function to a certain moment, rather than to execute it immediately.
In Currying, we can use delayed execution to implement partial application and combination of functions.
Specifically, we can divide the parameters of the Curry function into two parts: one is the parameters that need to be passed in immediately, and the other is the parameters that need to be passed in delayed.
In this way, we can pass in delay parameters when needed, thereby achieving more flexible function combinations.
Here is a simple example that demonstrates how to use delayed execution to implement function currying:
function add(x, y) {
return x + y;
}
function curry(fn) {
return function curried(...args) {
if ( >= ) {
return (this, args);
} else {
return function(...args2) {
return (this, (args2));
};
}
};
}
const addCurried = curry(add);
const add5 = addCurried(5);
(add5(3)); // 8
(addCurried(5)(3)); // 8
In the above example, we define aaddFunction and onecurryfunction.curryThe function takes a function as an argument and returns a new Curry function.
This Curry function can accept any number of parameters and execute the original function when the number of parameters reaches the number required by the function. existcurryIn functions, we use delayed execution to implement some applications of functions.
Specifically, we return a new function in the Curry function, which takes a parameter and merges this parameter with the previously passed parameters.
When the number of parameters reaches the number required by the original function, we can execute the original function.
In the above example, we first usecurryThe function willaddThe function is converted into a curry function.
Then, we useaddCurried(5)To create a new functionadd5, this function will5Passed in as the first parameteraddfunction.
Finally, we can useadd5(3)oraddCurried(5)(3)To calculate5 + 3The value of8。
In general, delayed execution is a very useful technique that allows us to more flexibly combine and reuse functions. In Currying, we can use delayed execution to implement partial application and composition of functions, making our code more concise and easy to maintain.
III. Some applications
Some applications refer to passing only some parameters when calling a function, not all parameters. This creates a new function that only needs to pass the remaining parameters to complete the call. This technique allows us to more conveniently perform function multiplexing and combination.
Here is an example of using function currylation to implement some applications:
function add(a, b, c) {
return a + b + c;
}
// Use function currying to implement some applicationsconst add5 = (null, 5);
const add10 = (null, 10);
(add5(2, 3)); // Output 10(add10(2, 3)); // Output 15In the example above, we define an add function that takes three parameters. We then use the bind method of the function Currying function to create two new functions, add5 and add10, which bind the first argument to 5 and 10 respectively.
In this way, we can use these two new functions to implement some applications, and we only need to pass the remaining two parameters to complete the call.
4. Function combination
Another commonly used function is that we can combine multiple functions into a new function.
Here is a simple example that demonstrates how to use function combinations:
function add(x, y) {
return x + y;
}
function multiply(x, y) {
return x * y;
}
function compose(...fns) {
return function composed(result) {
for (let i = - 1; i >= 0; i--) {
result = fns[i].call(this, result);
}
return result;
}
}
const addAndMultiply = compose(
(null, 2),
(null, 1)
);
(addAndMultiply(3, 4)); // 14
In the above example, we define two functionsaddandmultiply, they implement addition and multiplication respectively.
Then we defined acomposeA function, which takes any number of functions as parameters and returns a new function, which combines these functions to form a new function.
We usecomposeThe function willaddandmultiplyCombine functions into a new functionaddAndMultiply。
This new function will be called firstaddThe function adds parameter 1 and then calls itmultiplyThe function multiplies the result by 2. Finally we calladdAndMultiply(3, 4), it returns 14.
This is the end of this article about in-depth understanding of function curling in JavaScript. For more related content on JavaScript function curling, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!