Functional Programming Best Practices in JavaScript

Functional Programming Best Practices in JavaScript

Functional programming is powerful but has best practices. Here is how to write clean, maintainable functional JavaScript.

1. Prefer Pure Functions

Pure functions (same input, same output, no side effects) are easier to test, debug, and reason about. Keep side effects at the edges of your application.

2. Use Immutability

// good: return new copies
const newArr = [...arr, 4];
const newObj = { ...obj, x: 2 };

// bad: mutate
arr.push(4);
obj.x = 2;
``
Use spread, `Object.assign`, or libraries like Immer for complex state.

### 3. Use `map`/`filter`/`reduce` Instead of Loops

```js
// good: declarative
const result = arr.filter((n) => n > 1).map((n) => n * 2);

// avoid: imperative (unless performance is critical)
const result = [];
for (const n of arr) {
  if (n > 1) result.push(n * 2);
}
``
### 4. Compose Small Functions

```js
const isValid = (n) => n > 0;
const double = (n) => n * 2;
const process = (arr) => arr.filter(isValid).map(double);
``
Small, single-purpose functions are easier to test and reuse.

### 5. Avoid Side Effects in Callbacks

```js
// bad: side effect in map
arr.map((n) => { console.log(n); return n * 2; });

// good: separate concerns
arr.forEach((n) => console.log(n));
const doubled = arr.map((n) => n * 2);
``
### 6. Always Pass an Initial Value to `reduce`

```js
const sum = arr.reduce((acc, n) => acc + n, 0);
``
This avoids bugs with empty arrays and type mismatches.

### 7. Use `const` by Default

```js
const x = 5;
const double = (n) => n * 2;
``
`const` prevents accidental reassignment, which aligns with immutability.

### 8. Use `pipe` or `compose` for Pipelines

```js
const pipeline = pipe(filter(isValid), map(double), reduce(sum, 0));
const result = pipeline(arr);
``
This is more readable than deep nesting or long chains.

### 9. Keep Functions Small

Each function should do one thing. If a function does too much, split it. Small functions are easier to test, name, and compose.

### 10. Use TypeScript for Type Safety

TypeScript catches type errors at compile time, which complements FP's focus on predictability.

### The Takeaway

FP best practices: prefer pure functions, use immutability (spread, new copies), use `map`/`filter`/`reduce` instead of loops, compose small functions, avoid side effects in callbacks, always pass an initial value to `reduce`, use `const` by default, use `pipe`/`compose` for pipelines, keep functions small, and use TypeScript for type safety.