Introduction

Functional programming (FP) is a programming paradigm that treats computation as the evaluation of mathematical functions. In JavaScript, FP allows for more readable, maintainable, and scalable code. This blog post explores functional programming concepts, benefits, and practical applications in JavaScript.

---

Table of Contents

1. What is Functional Programming?
2. Core Principles of FP
   • Immutability
   • Pure Functions
   • First-Class Functions
   • Higher-Order Functions
3. Functional Programming Techniques
   • Map, Filter, and Reduce
   • Function Composition
   • Currying
   • Recursion
4. Functional vs Object-Oriented Programming
5. Real-World Applications of FP
6. Conclusion

---

1. What is Functional Programming?

Functional Programming (FP) focuses on pure functions, avoiding shared state and mutable data. It emphasizes:

• Declarative programming over imperative programming.
• Composability, making small, reusable functions.

---

2. Core Principles of FP

Immutability

Data cannot be changed once created. Instead, new data structures are returned.

const numbers = [1, 2, 3];
const newNumbers = [...numbers, 4];
console.log(newNumbers); // [1, 2, 3, 4]

Pure Functions

A function is pure if:

1. It depends only on its input.
2. It has no side effects.

const add = (a, b) => a + b;
console.log(add(2, 3)); // 5

First-Class Functions

Functions can be assigned to variables and passed as arguments.

const greet = () => "Hello!";
const welcome = greet;
console.log(welcome()); // "Hello!"

Higher-Order Functions

Functions that accept other functions as parameters or return them.

const operate = (fn, a, b) => fn(a, b);
console.log(operate(add, 5, 10)); // 15

---

3. Functional Programming Techniques

Map, Filter, and Reduce

• map(): Transforms each array element.
• filter(): Filters elements based on a condition.
• reduce(): Accumulates values.

const nums = [1, 2, 3, 4];
const squared = nums.map(x => x * x);
console.log(squared); // [1, 4, 9, 16]

const evenNums = nums.filter(x => x % 2 === 0);
console.log(evenNums); // [2, 4]

const sum = nums.reduce((acc, val) => acc + val, 0);
console.log(sum); // 10

Function Composition

Combining multiple functions into one.

const multiply = x => x * 2;
const subtract = x => x - 3;
const compose = (f, g) => x => f(g(x));
console.log(compose(multiply, subtract)(5)); // 4

Currying

Transforming a function with multiple arguments into a sequence of functions.

const curriedAdd = a => b => a + b;
console.log(curriedAdd(2)(3)); // 5

Recursion

A function calls itself to solve problems.

const factorial = n => (n === 0 ? 1 : n * factorial(n - 1));
console.log(factorial(5)); // 120

---

4. Functional vs Object-Oriented Programming

Feature	Functional Programming	Object-Oriented Programming
Data Mutability	Immutable	Mutable
Code Structure	Declarative	Imperative
State Management	Stateless Functions	Objects with State
Function Handling	First-Class, Pure	Methods inside Objects

---

5. Real-World Applications of FP

• React & Redux rely heavily on functional programming.
• Data transformation pipelines use map(), filter(), and reduce().
• Serverless functions benefit from stateless, pure functions.

---

6. Conclusion

Mastering functional programming in JavaScript leads to cleaner, more efficient code. By embracing pure functions, immutability, and higher-order functions, you can build scalable applications.

🔹 Next Blog Post: “Exploring JavaScript Performance Optimization” – Stay tuned! 🚀