What does `higher-order` mean in JavaScript

In JavaScript, the term "higher-order" refers to functions that can take other functions as arguments and/or return functions as their results. This concept is a cornerstone of functional programming but is also widely used across different programming paradigms within JavaScript due to its flexibility and expressiveness. Higher-order functions allow for more abstract and concise code, enabling developers to write more reusable and modular components.

Characteristics of Higher-Order Functions

Accept Functions as Arguments: Higher-order functions can take one or more functions as parameters. This allows for a flexible code structure where behavior can be passed in and varied dynamically.
Return Functions as Output: They can also return functions, enabling the creation of function factories or the use of function composition, where multiple functions are combined to create new capabilities.

Examples of Higher-Order Functions

JavaScript's standard library is replete with higher-order functions, especially methods on arrays like .map(), .filter(), and .reduce(). Here are some examples illustrating how higher-order functions are used:

Accepting Functions as Arguments

function repeat(n, action) {
  for (let i = 0; i < n; i++) {
    action(i);
  }
}

// Using `repeat` to log numbers 0 to 4
repeat(5, console.log);

In this example, repeat is a higher-order function because it takes another function, action, as an argument.

Returning Functions as Output

function greaterThan(n) {
  return m => m > n;
}

let greaterThan10 = greaterThan(10);
console.log(greaterThan10(11)); // true

Here, greaterThan is a higher-order function because it returns a new function that checks if a number is greater than a given value.

Array Methods

const numbers = [1, 2, 3, 4, 5];

const doubled = numbers.map(number => number * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

The .map() method is a higher-order function because it takes a function as an argument, which is applied to every item in the array to produce a new array.

Benefits of Higher-Order Functions

Modularity and Reusability: They help in breaking down tasks into smaller, reusable functions that can be combined in various ways.
Abstraction: Higher-order functions can abstract or encapsulate behaviors, making code more general and flexible.
Expressiveness: They allow for more expressive and concise code, making it easier to understand the programmer's intent.