Functional Programming ka Funda

Understand how Functional Programming works with Fullstackgada

🎯 Functional Programming Kya Hai?

Functional Programming (FP): Code jo functions par based ho, saaf-suthra, bina side effects ke, aur aasani se reuse ho sake.

💃 Daya ka Garba Analogy

💃

Pure Function (Daya ka Garba): Same steps, same josh! Same input = Same output

🐍

Impure Function (Kabhi Garba, Kabhi Nagin): Kabhi result aisa, kabhi waisa - koi bharosa nahi!

Upar ke buttons click karo to Functional Programming ke concepts dekho!

⚖️ FP vs OOP vs Imperative

Kaun si approach kab use karein? Har style ka apna maza aur jagah hai!

/* Upar se koi programming style choose karo to code examples dekho */

🤔 Kab Use Karein?

Koi style select karo to dekho kab use karna hai!

🌟 Functional Programming Kyun Chune?

Jethalal ke Hisaab se FP ke Fayde: Bug-free, predictable code, safai se testing, aur aasaan reuse!

// ✅ Functional: Predictable jaise Daya ka Garba
const calculateDiscount = (price, discountPercent) => {
  return price - (price * discountPercent / 100);
};
// Hamesha same result
console.log(calculateDiscount(1000, 10)); // Hamesha 900
console.log(calculateDiscount(1000, 10)); // Hamesha 900
console.log(calculateDiscount(1000, 10)); // Hamesha 900

// ❌ Imperative: Unpredictable jaise Nagin Dance
let globalDiscount = 10;
function calculateDiscountUnpredictable(price) {
  globalDiscount += Math.random() * 5; // Har baar badalta hai!
  return price - (price * globalDiscount / 100);
}
// Har baar alag results
console.log(calculateDiscountUnpredictable(1000)); // 875.23
console.log(calculateDiscountUnpredictable(1000)); // 832.45
console.log(calculateDiscountUnpredictable(1000)); // 798.67

Predictability test karne ke liye click karo...

// ✅ Functional: Testing mein aasaan
const add = (a, b) => a + b;
const multiply = (a, b) => a * b;
const calculateArea = (length, width) => multiply(length, width);
// Testing seedha-sada - koi mocking nahi chahiye
// Test 1: add function
assert(add(2, 3) === 5); // ✅ Pass
// Test 2: multiply function
assert(multiply(4, 5) === 20); // ✅ Pass
// Test 3: calculateArea function
assert(calculateArea(10, 5) === 50); // ✅ Pass

// ❌ Object-Oriented: Testing mein jhamela
class Calculator {
  constructor() {
    this.history = [];
    this.database = new Database(); // Bahar ka dependency
  }
  add(a, b) {
    const result = a + b;
    this.history.push({operation: 'add', result});
    this.database.save(result); // Side effect
    return result;
  }
}
// Testing ke liye mocking, setup, teardown chahiye
// Database mock karna, history check karna, etc.

Testing comparison dekhne ke liye click karo...

// ✅ Functional: Bahut reusable
const map = (fn, array) => array.map(fn);
const filter = (predicate, array) => array.filter(predicate);
const reduce = (reducer, initial, array) => array.reduce(reducer, initial);
// Reusable utility functions
const double = x => x * 2;
const isEven = x => x % 2 === 0;
const sum = (acc, curr) => acc + curr;
// Kahin bhi, kisi bhi data ke saath use karo
const numbers = [1, 2, 3, 4, 5];
const doubled = map(double, numbers);     // [2,4,6,8,10]
const evens = filter(isEven, numbers);    // [2, 4]
const total = reduce(sum, 0, numbers);    // 15

// ❌ Object-Oriented: Limited reusability
class NumberProcessor {
  constructor(numbers) {
    this.numbers = numbers;
    this.processed = [];
  }
  doubleNumbers() {
    this.processed = this.numbers.map(x => x * 2);
    return this;
  }
  filterEvens() {
    this.processed = this.processed.filter(x => x % 2 === 0);
    return this;
  }
}
// Alag data types ke liye logic reuse nahi kar sakte

Reusability demo dekhne ke liye click karo...

// ✅ Functional: Debugging mein aasaan - alag-alag functions
const getUserName = (user) => user.name;
const formatName = (name) => name.toUpperCase();
const addGreeting = (name) => `Hello, ${name}!`;
// Debug karna aasaan - har function alag test kar sakte hain
const user = {name: "Jethalal"};
const name = getUserName(user);        // "Jethalal"
const formatted = formatName(name);    // "JETHALAL"
const greeting = addGreeting(formatted); // "Hello, JETHALAL!"
// Har step alag se debug kar sakte hain

// ❌ Procedural: Debugging mein mushkil - sab mixed up
function processUser(user) {
  let result = "";
  if (user && user.name) {
    let name = user.name;
    // Side effect: global state badalta hai
    lastProcessedUser = user;
    name = name.toUpperCase();
    result = "Hello, " + name + "!";
    // Dusra side effect: logging
    console.log("Processed: " + result);
  }
  return result;
}
// Debug karna mushkil - sab kuch ghulmil gaya

Debugging demo dekhne ke liye click karo...

🌍 Real-world FP ke Applications

⚛️ React

Functional components, hooks, pure render functions

📊 Data Processing

map(), filter(), reduce() se data transform karo

🔒 State Management

Redux, Zustand - immutable state updates

🧪 Testing

Pure functions ko test aur mock karna aasaan

🚀 Performance

Memoization, lazy evaluation, parallel processing

🎯 APIs

Stateless functions, middleware, data transformation

🔍 Programming Paradigms ka Comparison

Aspect	🔧 Functional	🏗️ Object-Oriented	💻 Imperative
Main Focus	Functions aur unka composition	Objects aur unka interaction	Ek-ek karke instructions
Data Kaise Handle Hota Hai	Immutable data, pure transformations	Objects mein encapsulated, mutable	Variables aur assignments se
Problem Solving	Chhote, pure functions compose karo	Real-world entities ko objects banakar model karo	Sequential steps mein tod do
Best For	Data transformation, calculations, parallel processing	Bade applications, GUI, business logic	Simple scripts, algorithms, system programming
Testing	Aasaan - pure functions, koi dependency nahi	Medium - mocking, setup chahiye	Mushkil - side effects, global state
Debugging	Aasaan - alag-alag, predictable functions	Medium - encapsulated par complex	Mushkil - tangled logic, side effects
Example Languages	Haskell, Clojure, F#, JavaScript (FP style)	Java, C++, Python, JavaScript (OOP style)	C, Assembly, JavaScript (imperative style)
Jethalal ka Take	Daya ka Garba - predictable, consistent	Gokuldham Society - organized, structured	Tapu ki Masti - chaotic par direct

🤔 Kaun sa Paradigm Kab Chune?

Scenario	Recommended Paradigm	Kyun?
Data Processing & Analytics	🔧 Functional	Pure functions, aasaan testing, parallel processing
Web UI Development	🔧 Functional + 🏗️ OOP	React (functional components) + component architecture
Bade Enterprise Applications	🏗️ Object-Oriented	Behtar organization, encapsulation, maintainability
Mathematical Calculations	🔧 Functional	Pure functions mathematical functions se match karte hain
System Programming	💻 Imperative	Direct hardware control, performance critical
API Development	🔧 Functional	Stateless, predictable, test karna aasaan
Game Development	🏗️ OOP + 💻 Imperative	Object modeling + performance optimization