Higher-Order Functions Kya Hote hain?

Higher-Order Functions ka Introduction

JavaScript mein Higher-Order Functions woh functions hote hain jo ya to kisi function ko as an argument 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.

map(), filter(), aur reduce() iske sabse popular examples hain. Inka use hum arrays ke elements par operations perform karne ke liye karte hain bina explicit for loops likhe.

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. 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); // Output: [2, 4, 6, 8]
console.log(numbers); // Original array remains unchanged: [1, 2, 3, 4]

2. filter() Function

JavaScript mein filter() ek built-in array method hai jo ek naya array return karta hai, jismein sirf wahi elements hote hain jo ek specific condition ko pass karte hain. Yeh 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:

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); // Output: [25, 30, 50]

3. reduce() Function

JavaScript ka reduce() function ek 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).

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); // 0 is the initial value for the accumulator
console.log(sum); // Output: 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); // [{ name: 'Laptop', ...}, { name: 'Tablet', ...}]

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

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.