Indracit.dev
Currying in JavaScript

Currying in JavaScript

Indracit S's photo
Indracit S
·

2 min read

Currying is a functional programming technique that allows you to transform a function with multiple arguments into a sequence of functions, each taking a single argument. The curried function can be invoked with one argument at a time or with all the arguments at once. JavaScript supports currying through various techniques, and I'll explain them in detail.

1. Manual Currying:

The manual currying approach involves creating a function that returns a new function until all the arguments are satisfied. Here's an example:

function add(x) {
  return function(y) {
    return x + y;
  };
}

const addFive = add(5);
console.log(addFive(3)); // Output: 8

In this example, add is a curried function that takes an argument x and returns a new function that takes an argument y and returns the sum of x and y. We can create a partially applied function addFive by invoking add with the argument 5. addFive can then be called with the remaining argument 3 to get the final result.

2. Using Function.prototype.bind():

The bind() method in JavaScript can be used to curry a function by partially applying arguments. Here's an example:

function multiply(x, y) {
  return x * y;
}

const multiplyByTwo = multiply.bind(null, 2);
console.log(multiplyByTwo(5)); // Output: 10

In this example, we use bind() to create a new function multiplyByTwo by partially applying the first argument as 2. The null argument is used as the this value within the function (not relevant in this case). When multiplyByTwo is called with the argument 5, it returns the result of multiplying 2 and 5.

3. Using arrow functions:

Arrow functions provide a concise way to create curried functions. Here's an example:

const multiply = x => y => x * y;

const multiplyByTwo = multiply(2);
console.log(multiplyByTwo(5)); // Output: 10

In this example, the multiply function is defined using arrow functions. It takes an argument x and returns another arrow function that takes an argument y and returns the product of x and y. The multiplyByTwo function is created by invoking multiply with the argument 2. It can then be called with the remaining argument 5 to get the final result.

Currying can be beneficial when you want to create reusable functions or when you want to partially apply arguments to a function to create specialized versions of it. It allows for more flexibility and composability in functional programming paradigms.

JavaScript