Functional Programming in JavaScript: The Basics

Functional Programming in JavaScript: The Basics

Functional programming (FP) is a style of programming based on pure functions, immutability, and composition. JavaScript supports FP because functions are first-class citizens.

Core Principles

1. Pure functions: same input, same output, no side effects.
2. Immutability: do not mutate data; return new copies.
3. Function composition: chain small functions into pipelines.
4. First-class functions: functions are values.
5. Higher-order functions: functions take/return functions.

Pure Functions

// pure: same input, same output, no side effects
function add(a, b) { return a + b; }

// impure: modifies external state
let total = 0;
function addToTotal(n) { total += n; return total; }
``
Pure functions are easier to test, debug, and reason about.

### Immutability

```js
// bad: mutates the array
arr.push(4);

// good: returns a new array
const newArr = [...arr, 4];

// bad: mutates the object
obj.x = 2;

// good: returns a new object
const newObj = { ...obj, x: 2 };
``
Immutable data is easier to track and prevents bugs from shared mutation.

### Composition

```js
const addOne = (n) => n + 1;
const double = (n) => n * 2;
const addOneThenDouble = (n) => double(addOne(n));
addOneThenDouble(5); // 12
``
Or with a `compose` utility:

```js
const compose = (f, g) => (x) => f(g(x));
const result = compose(double, addOne)(5); // 12
``
### Declarative vs Imperative

```js
// imperative: how to do it
const result = [];
for (let i = 0; i < arr.length; i++) {
  if (arr[i] > 1) result.push(arr[i] * 2);
}

// declarative: what to do
const result = arr.filter((n) => n > 1).map((n) => n * 2);
``
FP is declarative: you describe what you want, not how to do it.

### The Takeaway

Functional programming in JS is based on pure functions (no side effects), immutability (return new copies, do not mutate), composition (chain small functions), and declarative style (what, not how). Use `map`/`filter`/`reduce` and spread/ `Object.assign` for immutability.