Higher-Order Functions in JavaScript: A Practical Guide

Dec 4, 2022

Functions that take one other function as an argument, or that outline a function because the return value, are called higher-order functions.

JavaScript can accept higher-order functions. This ability to handle higher-order functions, amongst other characteristics, makes JavaScript certainly one of the programming languages well-suited for functional programming.

JavaScript Treats Functions as First-Class Residents

You will have heard that JavaScript functions are first-class residents. This implies functions in JavaScript are objects.

They’ve the kind Object, they could be assigned as the worth of a variable, they usually could be passed and returned just like all other reference variable.

First-class functions give JavaScript special powers and enable us to learn from higher-order functions.

Because functions are objects, JavaScript is certainly one of the favored programming languages that supports a natural approach to functional programming.

In actual fact, first-class functions are so native to JavaScript’s approach that I bet you’ve been using them without even interested by it.

Higher-Order Functions Can Take a Function as an Argument

If you happen to’ve done much JavaScript web development, you’ve probably come across functions that use a callback.

A callback function is a function that executes at the tip of an operation, once all other operations are complete.

Often, we pass this function as an argument last, after other parameters. It’s often defined inline as an anonymous function. Callback functions depend on JavaScript’s ability to take care of higher-order functions.

JavaScript is a single-threaded language. This implies just one operation can execute at a time.

To avoid operations blocking one another or the system’s principal thread (which might cause deadlock), the engine ensures all operations execute so as. They’re queued along this single thread until it’s protected for an additional transaction of code to occur.

The flexibility to pass in a function as an argument and run it after the parent function’s other operations are complete is crucial for a language to support higher-order functions.

Callback functions in JavaScript allow for asynchronous behavior, so a script can proceed executing other functions or operations while waiting for a result.

The flexibility to pass a callback function is critical when coping with resources that will return a result after an undetermined time period.

This higher-order function pattern may be very useful in an internet development. A script may send a request off to a server, after which must handle the response at any time when it arrives, without requiring any knowledge of the server’s network latency or processing time.

Node.js continuously uses callback functions to make efficient use of server resources. This asynchronous approach can be useful within the case of an app that waits for user input before performing a function.

Example: Passing an Alert Function to an Element Event Listener

Consider this snippet of straightforward JavaScript that adds an event listener to a button.

So Clickable

document.getElementById(“clicker”).addEventListener(“click”, function() {
alert(“you triggered “ +;

This script uses an anonymous inline function to display an alert.

But it surely could just as easily have used a individually defined function and passed that named function to the addEventListener method:

var proveIt = function() {
alert(“you triggered “ +;

document.getElementById(“clicker”).addEventListener(“click”, proveIt);

We haven’t just demonstrated higher-order functions by doing this. We’ve made our code more readable and resilient, and separated functionality for various tasks (listening for clicks vs. alerting the user).

How Higher-Order Functions Support Code Reusability

Our little proveIt() function is structurally independent of the code around it, at all times returning the id of whatever element was triggered. This approach to operate design is on the core of functional programming.

This little bit of code could exist in any context where you display an alert with the id of a component, and might be called with any event listener.

The flexibility to exchange an inline function with a individually defined and named function opens up a world of possibilities.

In functional programming, we attempt to develop pure functions that don’t alter external data and return the identical result for a similar input each time.

We now have certainly one of the essential tools to assist us develop a library of small, targeted higher-order functions you should utilize generically in any application.

Note: Passing Functions vs. Passing the Function Object

Note that we passed proveIt and never proveIt() to our addEventListener function.

Whenever you pass a function by name without parentheses, you might be passing the function object itself.

Whenever you pass it with parentheses, you might be passing the results of executing that function.

Returning Functions as Results with Higher-Order Functions

Along with taking functions as arguments, JavaScript allows functions to return other functions consequently.

This is smart since functions are simply objects. Objects (including functions) could be defined as a function’s returned value, identical to strings, arrays, or other values.

But what does it mean to return a function consequently?

Functions are a strong technique to break down problems and create reusable pieces of code. Once we define a function because the return value of a higher-order function, it will probably function a template for brand new functions!

That opens the door to a different world of functional JavaScript magic.

Say you’ve read one too many articles about Millennials and grown bored. You select you should replace the word Millennials with the phrase Snake People each time it occurs.

Your impulse may be simply to jot down a function that performed that text alternative on any text you passed to it:

var snakify = function(text) {
return text.replace(/millenials/ig, “Snake People”);
console.log(snakify(“The Millenials are at all times as much as something.”));

That works, nevertheless it’s pretty specific to this one situation. Perhaps your patience has also outgrown articles concerning the Baby Boomers. You’d wish to make a custom function for them as well.

But even with such a straightforward function, you don’t need to need to repeat the code that you just’ve written when you’ll be able to start with a higher-order function as a substitute.

var hippify = function(text) {
return text.replace(/baby boomers/ig, “Aging Hippies”);
console.log(hippify(“The Baby Boomers just look the opposite way.”));

But what in case you decided that you just desired to do something fancier to preserve the case in the unique string? You would need to modify each of your recent functions to do that.

That’s a hassle, and it makes your code more brittle and harder to read. In situations like this, we are able to use a higher-order function as an answer.

Constructing a Template Higher-Order Function

What you actually need is the flexibleness to have the option to exchange any term with some other term in a template function, and define that behavior as a foundational function from which you’ll be able to construct recent custom functions.

With the power to assign functions as return values, JavaScript offers up ways to make that scenario way more convenient:

var attitude = function(original, alternative, source) {
return function(source) {
return source.replace(original, alternative);

var snakify = attitude(/millenials/ig, “Snake People”);
var hippify = attitude(/baby boomers/ig, “Aging Hippies”);

console.log(snakify(“The Millenials are at all times as much as something.”));

console.log(hippify(“The Baby Boomers just look the opposite way.”));

What we’ve done is isolate the code that does the actual work into a flexible and extensible attitude function. It encapsulates all the work needed to switch any input string using the unique phrase because the initial value, and output a alternative phrase with some attitude.

What will we gain after we define this recent function as a reference to the attitude higher-order function, pre-populated with the primary two arguments it takes? It allows the brand new function to take whatever text you pass it and use that argument within the return function we’ve defined because the attitude function’s output.

JavaScript functions don’t care concerning the variety of arguments you pass them.

If the second argument is missing, it should treat it as undefined. And it should do the identical after we opt not to offer a 3rd argument, or any variety of additional arguments, too.

Further, you’ll be able to pass that additional argument in later. You’ll be able to do that while you’ve defined the higher-order function you would like to call, as just demonstrated.

Simply define it as a reference to a function a higher-order function returns with a number of arguments left undefined.

Go over that a couple of times if you should, so that you fully understand what’s happening.

We’re making a template higher-order function that returns one other function. Then we’re defining that newly returned function, minus one attribute, as a custom implementation of the template function.

All of the functions you create this fashion will inherit the working code from the higher-order function. Nonetheless, you’ll be able to predefine them with different default arguments.

You’re Already Using Higher-Order Functions

Higher-order functions are so basic to the best way JavaScript works, you’re already using them.

Each time you pass an anonymous or callback function, you’re actually taking the worth that the passed function returns, and using that as an argument for an additional function (equivalent to with arrow functions).

Developers develop into conversant in higher-order functions early within the means of learning JavaScript. It’s so inherent to JavaScript’s design that the necessity to learn concerning the concept driving arrow functions or callbacks may not arise until in a while.

The flexibility to assign functions that return other functions extends JavaScript’s convenience. Higher-order functions allow us to create custom-named functions to perform specialized tasks with shared template code from a first-order function.

Each of those functions can inherit any improvements made within the higher-order function down the road. This helps us avoid code duplication, and keeps our source code clean and readable.

If you happen to ensure your functions are pure (they don’t alter external values and at all times return the identical value for any given input), you’ll be able to create tests to confirm that your code changes don’t break anything while you update your first-order functions.


Now that you already know how a higher-order function works, you’ll be able to start interested by ways you’ll be able to reap the benefits of the concept in your personal projects.

One in all the nice things about JavaScript is that you would be able to mix functional techniques right in with the code you’re already conversant in.

Try some experiments. Even in case you start by utilizing a higher-order function for the sake of it, you’ll develop into conversant in the additional flexibility they supply soon enough.

A bit of work with higher-order functions now can improve your code for years to return.