Understanding First-Class Functions in JavaScript

Understanding First-Class Functions in JavaScript

JavaScript is a versatile programming language that supports many programming paradigms, including functional programming. One of the key features of functional programming is the concept of first-class functions. In this article, we will explore what first-class functions are and how they work in JavaScript.

What are First-Class Functions?

In JavaScript, functions are treated as first-class citizens, which means that they can be treated like any other value, such as a number, string, or object. This means that functions can be passed as arguments to other functions, returned as values from functions, and assigned to variables or properties.

In other words, a first-class function is a function that can be:

  • Assigned to a variable
  • Passed as an argument to another function
  • Returned as a value from a function

Examples of First-Class Functions in JavaScript

Assigning a Function to a Variable

// Assigning a function to a variable
const greet = function(name) {
  console.log(`Hello, ${name}!`);

// Calling the function
greet('John'); // Output: Hello, John!

In the example above, we assigned the greet function to a variable called greet. We can now use the greet variable to call the function, just like we would with any other value.

Passing a Function as an Argument

// Passing a function as an argument
function calculate(num1, num2, operation) {
  return operation(num1, num2);

function add(num1, num2) {
  return num1 + num2;

function subtract(num1, num2) {
  return num1 - num2;

console.log(calculate(10, 5, add)); // Output: 15
console.log(calculate(10, 5, subtract)); // Output: 5

In the example above, we defined three functions: calculate, add, and subtract. The calculate function takes three arguments: num1, num2, and operation. The operation argument is a function that is used to perform a specific mathematical operation on num1 and num2. We can pass the add and subtract functions as arguments to the calculate function to perform addition and subtraction operations, respectively.

Returning a Function as a Value

// Returning a function as a value
function createMultiplier(multiplier) {
  return function(num) {
    return num * multiplier;

const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log(double(5)); // Output: 10
console.log(triple(5)); // Output: 15

In the example above, we defined a function called createMultiplier that takes a multiplier argument and returns a new function that multiplies its argument by the multiplier value. We can use the createMultiplier function to create new functions that multiply by different values. In this case, we created two new functions called double and triple that multiply their argument by 2 and 3, respectively.

Benefits of First-Class Functions

First-class functions provide a lot of flexibility and power when writing JavaScript code. They allow us to write more concise and reusable code, and they enable us to use higher-order functions, which are functions that take other functions as arguments or return functions as values.

Some of the benefits of first-class functions include:

  • Writing more concise and reusable code
  • Creating higher-order functions
  • Implementing function currying and partial application
  • Implementing function composition


In this article, we explored the concept of first-class functions in JavaScript. We learned that functions are treated as first-class citizens in JavaScript, which means they can be assigned to variables, passed as arguments to other functions, and returned as values from functions. We also saw some examples of how first-class functions can be used in JavaScript, and we discussed some of the benefits of using first-class functions in our code.