Pure functions Vs. Impure functions

In JavaScript, functions can be categorized as either pure functions or impure functions based on their behavior and effects. These categories help us understand how functions interact with data, maintain predictability, and manage side effects. Let's delve into the details of both types, along with examples:

Pure Functions

A pure function is a function that, given the same input, always produces the same output and has no side effects. In other words, its behavior is solely determined by its input parameters, and it doesn't modify any external state or data.

Characteristics of pure functions

  1. Deterministic: The same input will always result in the same output.
  2. No side effects: They don't modify external data or have observable interactions with the outside world, such as changing global variables, making network requests, or modifying the DOM.

Benefits of pure functions

  1. Predictable behavior
  2. Easier to test and reason about
  3. Can be parallelized and memoized
Example of a pure function:
function add(a, b) { return a + b; }

Impure Functions

An impure function is a function that has side effects or produces different output for the same input. Side effects can include modifying external data, printing to the console, making network requests, etc.

Characteristics of impure functions

  1. Side effects: They have actions beyond returning a value, like modifying external state.
  2. Non-deterministic: They can produce different results for the same input due to external factors.
Examples of impure functions:
let total = 0; // External state function addToTotal(amount) { total += amount; // Modifies external state } function getRandomNumber() { return Math.random(); // Non-deterministic result } function logMessage(message) { console.log(message); // Console output }
Examples of Impure Functions with Side Effects:
// Modifying global variable let counter = 0; function incrementCounter() { counter++; } // Making network request function fetchDataFromServer() { // Simulated network request return fetch('https://api.example.com/data'); } // Using and modifying external state const itemList = []; function addItemToList(item) { itemList.push(item); console.log(`Added ${item} to the list`); }

Understanding the distinction between pure and impure functions is crucial when designing robust and maintainable code.


Pure functions are generally favored as they lead to more predictable and testable codebases. Impure functions can introduce complexity and make it harder to reason about the behavior of the code. However, both types of functions have their place in programming; impure functions are necessary for interacting with the external world and producing side effects. The key is to manage impurity carefully and isolate it when necessary to maintain code clarity and predictability.