Pure Functions: Your Secret to Bug-Free Code!

2 min readJul 19, 2024

Hey there! Let’s dive into a cool concept that can make your code super predictable and bug-free: pure functions. Ready to make your code more awesome? Let’s get started!

What’s a Pure Function?

Pure functions are like a magical vending machine: put in a coin (input) and you always get the same snack (output) every time. No surprises!

Why Pure Functions Matter

Bugs happen when our code behaves unexpectedly. Pure functions help us keep things predictable. Here’s how:

Rule #1: No Side Effects

Side effects occur when a function does more than just return a value. It might change something outside its scope or rely on external data. Here are examples:

Unpredictable Example :

function addTodo(todo) {
  todos.push(todo); // Modifies the todos array
}

This function relies on todos outside of itself and changes it. Unpredictable!

Predictable Example :

function add(a, b) {
  return a + b; // No side effects
}

This function only returns a value based on its inputs.

Rule #2: Consistent Outputs

A function should always give the same output for the same input. If it doesn’t, it’s unpredictable.

Unpredictable Example:

const friends = ["Ben", "Lynn", "Alex"];
friends.splice(0, 1); // ["Ben"]
friends.splice(0, 1); // ["Lynn"]
friends.splice(0, 1); // ["Alex"]

splice changes the array and returns different results each time.

Predictable Example:

friends.slice(0, 1); // ["Ben"]
friends.slice(0, 1); // ["Ben"]
friends.slice(0, 1); // ["Ben"]

slice doesn’t change the array and always returns the same result.

Benefits of Pure Functions

Composable: Reusable in any context.
Cacheable: Always returns the same result for the same input.
Testable: Easy to test with predictable outputs.
Readable: Clear inputs and outputs, no surprises.

Real-World Example: isPrime Function

const isPrime = (n) => {
  if (n === 1) {
    return false;
  }
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) {
      return false;
    }
  }
  return true;
};

This function checks if a number is prime. It’s predictable, with no side effects and consistent outputs.

Pragmatic Predictability

Sometimes, you need functions with side effects, like network requests. When that happens, wrap them in a way that minimizes their impact.

The Big Reveal

Pure functions follow functional programming principles: no side effects and consistent outputs. Embrace them to make your code more predictable and less prone to bugs.

Happy coding! 🚀