Blog

Higher-Order Functions Kya Hote hain?

JavaScript mein Higher-Order Functions wo functions hote hain jo ya to kisi function ko argument ke roop mein accept karte hain, ya ek function return karte hain. Yeh ek powerful feature hai JavaScript ka jo programming ko zyada modular aur flexible banata hai.

Jaise ki map(), filter(), aur reduce() – yeh sab higher-order functions ke examples hain. Inka use hum arrays ke elements par operations perform karne ke liye karte hain bina for loops likhe.

Higher-order functions functional programming ka core part hain. Inse hum concise aur reusable code likh sakte hain. Agar koi function doosre function ko handle kare – chahe usse input le ya output de – to usse higher-order function kaha jata hai.

Yeh concept code ko clean aur readable banata hai.

JavaScript ke Popular Higher-Order Functions:

• map()
• filter()
• reduce()

1. map() Function:

map() ek built-in array method hai jo har ek element par ek function apply karta hai aur ek naya array return karta hai. Iska matlab hai ki original array change nahi hota, balki ek naya array banta hai jismein har element function ke result ke according hota hai.

Syntax:

array.map(function(currentValue, index, array) {
  // return new value
})

Example:

let numbers = [1, 2, 3, 4];
let double = numbers.map(function(num) {
  return num * 2;
});
console.log(double); // [2, 4, 6, 8]

Explanation:

• numbers ke har element par num * 2 apply hua
• Original array change nahi hua
• Naya array return hua double naam se

2. filter() Function:

JavaScript mein filter() ek built-in array method hai jo ek naye array ko return karta hai, jismein sirf wahi elements hote hain jo ek specific condition ko pass karte hain. Ye method har element par ek callback function apply karta hai. Agar condition true return karti hai, to element naye array mein add hota hai, warna skip kar diya jata hai.

Syntax hota hai: array.filter(callbackFunction). Callback function teen arguments leta hai: current value, index, aur original array (optional).

Syntax:

array.filter(function(currentValue, index, array) {
  return condition; // true ya false
})

Example:

let numbers = [10, 25, 30, 5, 50];
let filtered = numbers.filter(function(num) {
  return num > 20;
});
console.log(filtered); // [25, 30, 50]

Explanation:

• Condition: num > 20
• Sirf wohi numbers return hue jo 20 se bade hain
• Original array ko modify nahi kiya gaya

3. reduce() Function:

JavaScript ka reduce() function ek array method hai jo array ke sabhi elements ko ek single value mein reduce karta hai. Ye function ek callback function ko call karta hai har element ke liye, aur usmein do main arguments hote hain: accumulator (jo result store karta hai) aur currentValue (jo abhi process ho raha hota hai). Optional initial value bhi set ki ja sakti hai. Har iteration ke baad, accumulator update hota hai aur next element ke saath process continue hota hai.

Syntax:

array.reduce(function(accumulator, currentValue, index, array) {
  return updatedAccumulator;
}, initialValue)

Example:

let numbers = [1, 2, 3, 4];
let sum = numbers.reduce(function(acc, curr) {
  return acc + curr;
}, 0);
console.log(sum); // 10

Explanation:

• acc (accumulator) shuru mein 0 hai
• Har step par acc + curr hota jaata hai
• Last mein ek single value return hoti hai (yahan: 10)

Summary Table

Real Life Example:

let products = [
  { name: 'Laptop', price: 50000 },
  { name: 'Phone', price: 20000 },
  { name: 'Tablet', price: 30000 }
];

// map -> price extract karo
let prices = products.map(p => p.price); // [50000, 20000, 30000]

// filter -> sirf expensive items
let expensive = products.filter(p => p.price > 25000);

// reduce -> total price
let total = products.reduce((sum, p) => sum + p.price, 0);

Agar aap JavaScript seekh rahe ho ya kaam kar rahe ho, to in tino functions ka strong hold hona bahut zaroori hai. Inka combination aapko complex tasks ko simple code mein likhne ki power deta hai.

Quiz: Test Your Knowledge on Higher-Order Functions in JavaScript

Bonus: Practical Application!

 Aaj hi apne JavaScript code mein Higher-Order Functions ka istemal karke dekhein!

Higher-Order Functions jaise map, filter, aur reduce ko sahi tareeke se samajhne ke liye unka upayog karke data ko manipulate karna seekhein. Ye functions functional programming ka core part hain jo aapke code ko concise, clean, aur powerful banate hain.

Quiz ke through apna knowledge test karein aur fir apne real-world projects mein inka istemal karke apne coding skills ko next level tak le jaayein!