Partial Application in JavaScript

📆 · ⏳ 2 min read · · 👀

Introduction

In functional programming, functions are treated as first-class citizens, which means they can be passed around as arguments, returned as values, and even be partially applied.

Partial application is a technique where you create a new function by fixing some of the arguments of an existing function, while leaving others open for later use.

Partial application is especially useful when you have a function that takes multiple arguments, but you only want to fix some of them.

By fixing some arguments, you can create a new function that takes fewer arguments, making it easier to reuse and compose with other functions.

Partial Application in JavaScript

Let’s explore how partial application works in JavaScript with some examples.

To understand partial application, let’s start with a simple example of a function that takes two arguments and returns their sum:

function add(a, b) {
return a + b;
}

We can partially apply this function to fix one of the arguments, like this:

const add5 = add.bind(null, 5); // Fix the first argument to 5
add5(3); // Returns 8

In this example, we used the bind method to create a new function add5, which is the same as the add function, but with the first argument fixed to 5. Now, when we call add5(3), it returns the sum of 5 and 3, which is 8.

Another way to partially apply a function in JavaScript is to use a closure. Here’s an example:

function multiply(a, b) {
return a * b;
}
function partiallyApply(func, ...fixedArgs) {
return function (...remainingArgs) {
return func.apply(null, fixedArgs.concat(remainingArgs));
};
}
const multiplyBy3 = partiallyApply(multiply, 3); // Fix the first argument to 3
multiplyBy3(4); // Returns 12

In this example, we created a higher-order function partiallyApply, which takes a function and an array of fixed arguments, and returns a new function that applies those fixed arguments when called.

The returned function is created using a closure, which allows it to access the fixed arguments when called.

Conclusion

Partial application is a powerful technique in functional programming that can help you write cleaner, more reusable code. It allows you to create new functions by fixing some of the arguments of an existing function, while leaving others open for later use.

In this article, we explored how partial application works in JavaScript and how to use it with some examples. By mastering partial application, you can write more concise and effective code that is easier to maintain and debug.

You may also like

  • # javascript

    Write Secure JavaScript Applications

    Dive into the realm of writing secure JavaScript applications. Uncover practical strategies to shield your web apps from XSS and CSRF vulnerabilities, ensuring robust and safe software in an interconnected world.

  • # javascript

    Multi-Threaded JavaScript with Web Workers

    Are you tired of slow and unresponsive web applications? Do you want to improve the performance of your JavaScript code without sacrificing user experience? Look no further than JavaScript's Web Workers API. In this article, we'll explore the basics of web workers and how they can help you create multi-threaded web applications.

  • # javascript

    Asynchronous JavaScript Programming: A Guide to Promises, Async/Await, and Generators

    Asynchronous programming is essential in JavaScript to handle time-consuming operations and provide a better user experience. This article will provide a detailed guide to mastering asynchronous JavaScript programming with Promises, Async/Await, and Generators.