Why Pure Functions Matter in JavaScript: Benefits, Examples, and Best Practices

What is a pure function?

A pure function is defined by two rules: (1) given the same input parameters it always returns the same result, without relying on any external state; (2) it produces no observable side effects such as network requests, I/O, or data mutation.

If a function is called with identical arguments, it must always return identical results and must not depend on any external state.

The function must not cause any observable side effects (e.g., network calls, console output, DOM manipulation, random numbers, current time).

What are observable side effects?

An observable side effect is any interaction between the function and the outside world, such as modifying external variables or invoking other functions.

Note: If a pure function calls another pure function, no side effect is introduced and the result remains pure.

Typical side effects include:

Making an HTTP request

Printing data to the screen or console

DOM queries or manipulation

Calling Math.random() Reading the current time

Pure function example

Below is a pure JavaScript function that calculates the price after a 20% UK tax:

function priceAfterTax(productPrice) {
  return (productPrice * 0.20) + productPrice;
}

The function meets both purity criteria: it depends only on its input and has no side effects. Running it repeatedly with the same input always yields the same result.

Impure function example

Here is an impure JavaScript function that relies on an external variable:

var tax = 20;
function calculateTax(productPrice) {
  return (productPrice * (tax / 100)) + productPrice;
}

The result depends on the external tax variable, violating the first purity rule, so this function is impure.

Why are pure functions important in JavaScript?

Pure functions are heavily used in functional programming and are required by libraries such as React and Redux. They can also be mixed with impure functions where necessary (e.g., DOM event handlers), while keeping core logic pure.

Testability and refactoring

Pure functions are easy to test because identical inputs always produce identical outputs, making automated testing straightforward. They also simplify maintenance and refactoring, reducing hidden side effects that can lead to debugging nightmares.

Using pure functions results in higher‑quality, cleaner code. For more information see the Wikipedia article on pure functions and related guides.