M

MLOG

తెలుగు

జావాస్క్రిప్ట్ అర్రేలతో ఫంక్షనల్ ప్రోగ్రామింగ్ శక్తిని అన్‌లాక్ చేయండి. అంతర్నిర్మిత పద్ధతులను ఉపయోగించి మీ డేటాను సమర్థవంతంగా మార్చడం, ఫిల్టర్ చేయడం మరియు తగ్గించడం నేర్చుకోండి.

జావాస్క్రిప్ట్ అర్రేలతో ఫంక్షనల్ ప్రోగ్రామింగ్‌లో ప్రావీణ్యం

నిరంతరం అభివృద్ధి చెందుతున్న వెబ్ డెవలప్‌మెంట్ రంగంలో, జావాస్క్రిప్ట్ ఒక మూలస్తంభంగా కొనసాగుతోంది. ఆబ్జెక్ట్-ఓరియెంటెడ్ మరియు ఇంపరేటివ్ ప్రోగ్రామింగ్ పారాడిగ్మ్‌లు చాలా కాలంగా ఆధిపత్యం చెలాయిస్తున్నప్పటికీ, ఫంక్షనల్ ప్రోగ్రామింగ్ (FP) గణనీయమైన ఆదరణ పొందుతోంది. FP ఇమ్మ్యూటబిలిటీ, ప్యూర్ ఫంక్షన్‌లు మరియు డిక్లరేటివ్ కోడ్‌కు ప్రాధాన్యత ఇస్తుంది, ఇది మరింత బలమైన, నిర్వహించదగిన మరియు ఊహించదగిన అప్లికేషన్‌లకు దారితీస్తుంది. జావాస్క్రిప్ట్‌లో ఫంక్షనల్ ప్రోగ్రామింగ్‌ను స్వీకరించడానికి అత్యంత శక్తివంతమైన మార్గాలలో ఒకటి దాని స్థానిక అర్రే పద్ధతులను ఉపయోగించడం.

ఈ సమగ్ర గైడ్ జావాస్క్రిప్ట్ అర్రేలను ఉపయోగించి మీరు ఫంక్షనల్ ప్రోగ్రామింగ్ సూత్రాల శక్తిని ఎలా ఉపయోగించుకోవచ్చో వివరిస్తుంది. మేము కీలక భావనలను అన్వేషిస్తాము మరియు map, filter, మరియు reduce వంటి పద్ధతులను ఉపయోగించి వాటిని ఎలా అన్వయించాలో ప్రదర్శిస్తాము, ఇది మీరు డేటా మానిప్యులేషన్‌ను నిర్వహించే విధానాన్ని మారుస్తుంది.

ఫంక్షనల్ ప్రోగ్రామింగ్ అంటే ఏమిటి?

జావాస్క్రిప్ట్ అర్రేల గురించి తెలుసుకునే ముందు, ఫంక్షనల్ ప్రోగ్రామింగ్‌ను క్లుప్తంగా నిర్వచిద్దాం. దాని ప్రధాన భాగంలో, FP అనేది గణనను గణిత ఫంక్షన్‌ల మూల్యాంకనంగా పరిగణించే ఒక ప్రోగ్రామింగ్ పారాడిగ్మ్ మరియు స్టేట్ మార్చడం మరియు మ్యూటబుల్ డేటాను నివారిస్తుంది. కీలక సూత్రాలు:

ఈ సూత్రాలను అనుసరించడం వల్ల, సంక్లిష్టమైన అప్లికేషన్‌లలో కూడా కోడ్‌ను సులభంగా అర్థం చేసుకోవడానికి, పరీక్షించడానికి మరియు డీబగ్ చేయడానికి వీలవుతుంది. జావాస్క్రిప్ట్ యొక్క అర్రే పద్ధతులు ఈ భావనలను అమలు చేయడానికి సంపూర్ణంగా సరిపోతాయి.

జావాస్క్రిప్ట్ అర్రే పద్ధతుల శక్తి

జావాస్క్రిప్ట్ అర్రేలు సాంప్రదాయ లూప్‌లను (for లేదా while వంటివి) ఆశ్రయించకుండా అధునాతన డేటా మానిప్యులేషన్‌కు అనుమతించే అంతర్నిర్మిత పద్ధతుల యొక్క గొప్ప సమితితో వస్తాయి. ఈ పద్ధతులు తరచుగా కొత్త అర్రేలను తిరిగి ఇస్తాయి, ఇమ్మ్యూటబిలిటీని ప్రోత్సహిస్తాయి మరియు కాల్‌బ్యాక్ ఫంక్షన్‌లను అంగీకరిస్తాయి, ఇది ఫంక్షనల్ విధానాన్ని అనుమతిస్తుంది.

అత్యంత ప్రాథమిక ఫంక్షనల్ అర్రే పద్ధతులను అన్వేషిద్దాం:

1. Array.prototype.map()

map() పద్ధతి, పిలవబడిన అర్రేలోని ప్రతి మూలకంపై అందించిన ఫంక్షన్‌ను అమలు చేయడం ద్వారా వచ్చే ఫలితాలతో నింపబడిన కొత్త అర్రేను సృష్టిస్తుంది. ఇది ఒక అర్రేలోని ప్రతి మూలకాన్ని కొత్తదానిగా మార్చడానికి అనువైనది.

సింటాక్స్:

array.map(callback(currentValue[, index[, array]])[, thisArg])

కీలక లక్షణాలు:

ఉదాహరణ: ప్రతి సంఖ్యను రెట్టింపు చేయడం

మీ వద్ద సంఖ్యల అర్రే ఉందని మరియు మీరు ప్రతి సంఖ్యను రెట్టింపు చేసిన కొత్త అర్రేను సృష్టించాలనుకుంటున్నారని ఊహించుకోండి.

const numbers = [1, 2, 3, 4, 5];

// రూపాంతరం కోసం మ్యాప్ ఉపయోగించి
const doubledNumbers = numbers.map(number => number * 2);

console.log(numbers); // అవుట్‌పుట్: [1, 2, 3, 4, 5] (అసలు అర్రే మార్చబడలేదు)
console.log(doubledNumbers); // అవుట్‌పుట్: [2, 4, 6, 8, 10]

ఉదాహరణ: ఆబ్జెక్ట్‌ల నుండి ప్రాపర్టీలను సంగ్రహించడం

ఆబ్జెక్ట్‌ల అర్రే నుండి నిర్దిష్ట ప్రాపర్టీలను సంగ్రహించడం ఒక సాధారణ వినియోగం. మన దగ్గర వినియోగదారుల జాబితా ఉందని మరియు వారి పేర్లను మాత్రమే పొందాలనుకుంటున్నామని అనుకుందాం.

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

const userNames = users.map(user => user.name);

console.log(userNames); // అవుట్‌పుట్: ['Alice', 'Bob', 'Charlie']

2. Array.prototype.filter()

filter() పద్ధతి అందించిన ఫంక్షన్ ద్వారా అమలు చేయబడిన పరీక్షలో ఉత్తీర్ణులైన అన్ని మూలకాలతో కొత్త అర్రేను సృష్టిస్తుంది. ఇది ఒక షరతు ఆధారంగా మూలకాలను ఎంచుకోవడానికి ఉపయోగించబడుతుంది.

సింటాక్స్:

array.filter(callback(element[, index[, array]])[, thisArg])

కీలక లక్షణాలు:

ఉదాహరణ: సరి సంఖ్యలను ఫిల్టర్ చేయడం

సంఖ్యల అర్రే నుండి కేవలం సరి సంఖ్యలను మాత్రమే ఉంచడానికి ఫిల్టర్ చేద్దాం.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// సరి సంఖ్యలను ఎంచుకోవడానికి ఫిల్టర్ ఉపయోగించి
const evenNumbers = numbers.filter(number => number % 2 === 0);

console.log(numbers); // అవుట్‌పుట్: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(evenNumbers); // అవుట్‌పుట్: [2, 4, 6, 8, 10]

ఉదాహరణ: యాక్టివ్ యూజర్‌లను ఫిల్టర్ చేయడం

మన యూజర్‌ల అర్రే నుండి, యాక్టివ్‌గా మార్క్ చేయబడిన యూజర్‌ల కోసం ఫిల్టర్ చేద్దాం.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: false }
];

const activeUsers = users.filter(user => user.isActive);

console.log(activeUsers); 
/* అవుట్‌పుట్:
[
  { id: 1, name: 'Alice', isActive: true },
  { id: 3, name: 'Charlie', isActive: true }
]
*/

3. Array.prototype.reduce()

reduce() పద్ధతి, అర్రేలోని ప్రతి మూలకంపై యూజర్ అందించిన “రెడ్యూసర్” కాల్‌బ్యాక్ ఫంక్షన్‌ను క్రమంలో అమలు చేస్తుంది, మునుపటి మూలకంపై చేసిన గణన నుండి వచ్చిన రిటర్న్ విలువను పాస్ చేస్తుంది. అర్రేలోని అన్ని మూలకాలపై రెడ్యూసర్‌ను అమలు చేసిన చివరి ఫలితం ఒకే విలువగా ఉంటుంది.

ఇది అర్రే పద్ధతులలో అత్యంత బహుముఖమైనది మరియు అనేక ఫంక్షనల్ ప్రోగ్రామింగ్ ప్యాటర్న్‌లకు మూలస్తంభం. ఇది ఒక అర్రేను ఒకే విలువకు (ఉదా., మొత్తం, గుణకారం, లెక్కింపు లేదా కొత్త ఆబ్జెక్ట్ లేదా అర్రే కూడా) "తగ్గించడానికి" మిమ్మల్ని అనుమతిస్తుంది.

సింటాక్స్:

array.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

కీలక లక్షణాలు:

ఉదాహరణ: సంఖ్యలను కూడటం

మన అర్రేలోని అన్ని సంఖ్యలను కూడుదాం.

const numbers = [1, 2, 3, 4, 5];

// సంఖ్యలను కూడటానికి reduce ఉపయోగించి
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0); // 0 అనేది initialValue

console.log(sum); // అవుట్‌పుట్: 15

వివరణ:

ఉదాహరణ: ఆబ్జెక్ట్‌లను ఒక ప్రాపర్టీ ద్వారా గ్రూప్ చేయడం

ఒక ఆబ్జెక్ట్‌ల అర్రేను ఒక నిర్దిష్ట ప్రాపర్టీ ద్వారా విలువలు గ్రూప్ చేయబడిన ఆబ్జెక్ట్‌గా మార్చడానికి మనం reduceను ఉపయోగించవచ్చు. మన యూజర్‌లను వారి `isActive` స్థితి ద్వారా గ్రూప్ చేద్దాం.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: false }
];

const groupedUsers = users.reduce((acc, user) => {
  const status = user.isActive ? 'active' : 'inactive';
  if (!acc[status]) {
    acc[status] = [];
  }
  acc[status].push(user);
  return acc;
}, {}); // ఖాళీ ఆబ్జెక్ట్ {} అనేది initialValue

console.log(groupedUsers);
/* అవుట్‌పుట్:
{
  active: [
    { id: 1, name: 'Alice', isActive: true },
    { id: 3, name: 'Charlie', isActive: true }
  ],
  inactive: [
    { id: 2, name: 'Bob', isActive: false },
    { id: 4, name: 'David', isActive: false }
  ]
}
*/

ఉదాహరణ: సంభవించిన వాటిని లెక్కించడం

జాబితాలోని ప్రతి పండు యొక్క ఫ్రీక్వెన్సీని లెక్కిద్దాం.

const fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple'];

const fruitCounts = fruits.reduce((acc, fruit) => {
  acc[fruit] = (acc[fruit] || 0) + 1;
  return acc;
}, {});

console.log(fruitCounts); // అవుట్‌పుట్: { apple: 3, banana: 2, orange: 1 }

4. Array.prototype.forEach()

forEach() కొత్త అర్రేను తిరిగి ఇవ్వదు మరియు దాని ప్రాథమిక ఉద్దేశ్యం ప్రతి అర్రే మూలకం కోసం ఒక ఫంక్షన్‌ను అమలు చేయడం కాబట్టి ఇది తరచుగా మరింత ఇంపరేటివ్‌గా పరిగణించబడుతుంది, అయినప్పటికీ ఇది ఫంక్షనల్ ప్యాటర్న్‌లలో పాత్ర పోషించే ఒక ప్రాథమిక పద్ధతి, ప్రత్యేకించి సైడ్ ఎఫెక్ట్స్ అవసరమైనప్పుడు లేదా మార్చబడిన అవుట్‌పుట్ అవసరం లేకుండా పునరావృతం చేస్తున్నప్పుడు.

సింటాక్స్:

array.forEach(callback(element[, index[, array]])[, thisArg])

కీలక లక్షణాలు:

ఉదాహరణ: ప్రతి మూలకాన్ని లాగింగ్ చేయడం

const messages = ['Hello', 'Functional', 'World'];

messages.forEach(message => console.log(message));
// అవుట్‌పుట్:
// Hello
// Functional
// World

గమనిక: రూపాంతరాలు మరియు ఫిల్టరింగ్ కోసం, map మరియు filter వాటి ఇమ్మ్యూటబిలిటీ మరియు డిక్లరేటివ్ స్వభావం కారణంగా ప్రాధాన్యత ఇవ్వబడతాయి. కొత్త నిర్మాణంలోకి ఫలితాలను సేకరించకుండా ప్రతి అంశం కోసం ఒక చర్యను ప్రత్యేకంగా నిర్వహించాల్సిన అవసరం వచ్చినప్పుడు forEach ఉపయోగించండి.

5. Array.prototype.find() మరియు Array.prototype.findIndex()

ఈ పద్ధతులు ఒక అర్రేలో నిర్దిష్ట మూలకాలను గుర్తించడానికి ఉపయోగపడతాయి.

ఉదాహరణ: ఒక యూజర్‌ను కనుగొనడం

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

const bob = users.find(user => user.name === 'Bob');
const bobIndex = users.findIndex(user => user.name === 'Bob');
const nonExistentUser = users.find(user => user.name === 'David');
const nonExistentIndex = users.findIndex(user => user.name === 'David');

console.log(bob); // అవుట్‌పుట్: { id: 2, name: 'Bob' }
console.log(bobIndex); // అవుట్‌పుట్: 1
console.log(nonExistentUser); // అవుట్‌పుట్: undefined
console.log(nonExistentIndex); // అవుట్‌పుట్: -1

6. Array.prototype.some() మరియు Array.prototype.every()

ఈ పద్ధతులు అర్రేలోని అన్ని మూలకాలు అందించిన ఫంక్షన్ ద్వారా అమలు చేయబడిన పరీక్షలో ఉత్తీర్ణత సాధించాయో లేదో పరీక్షిస్తాయి.

ఉదాహరణ: యూజర్ స్థితిని తనిఖీ చేయడం

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true }
];

const hasInactiveUser = users.some(user => !user.isActive);
const allAreActive = users.every(user => user.isActive);

console.log(hasInactiveUser); // అవుట్‌పుట్: true (ఎందుకంటే బాబ్ నిష్క్రియంగా ఉన్నాడు)
console.log(allAreActive); // అవుట్‌పుట్: false (ఎందుకంటే బాబ్ నిష్క్రియంగా ఉన్నాడు)

const allUsersActive = users.filter(user => user.isActive).length === users.length;
console.log(allUsersActive); // అవుట్‌పుట్: false

// నేరుగా every ఉపయోగించి ప్రత్యామ్నాయం
const allUsersActiveDirect = users.every(user => user.isActive);
console.log(allUsersActiveDirect); // అవుట్‌పుట్: false

సంక్లిష్ట కార్యకలాపాల కోసం అర్రే పద్ధతులను చైన్ చేయడం

జావాస్క్రిప్ట్ అర్రేలతో ఫంక్షనల్ ప్రోగ్రామింగ్ యొక్క నిజమైన శక్తి మీరు ఈ పద్ధతులను కలిపి చైన్ చేసినప్పుడు ప్రకాశిస్తుంది. ఈ పద్ధతులలో చాలా వరకు కొత్త అర్రేలను తిరిగి ఇస్తాయి కాబట్టి (forEach మినహా), మీరు ఒక పద్ధతి యొక్క అవుట్‌పుట్‌ను మరొక పద్ధతి యొక్క ఇన్‌పుట్‌లోకి సజావుగా పైప్ చేయవచ్చు, సొగసైన మరియు చదవగలిగే డేటా పైప్‌లైన్‌లను సృష్టిస్తుంది.

ఉదాహరణ: యాక్టివ్ యూజర్ పేర్లను కనుగొని, వారి ఐడిలను రెట్టింపు చేయడం

అన్ని యాక్టివ్ యూజర్‌లను కనుగొని, వారి పేర్లను సంగ్రహించి, ఆపై *ఫిల్టర్ చేయబడిన* జాబితాలో ప్రతి పేరుకు దాని ఇండెక్స్‌ను సూచించే సంఖ్యతో ముందుగా జతచేయబడిన కొత్త అర్రేను సృష్టిద్దాం మరియు వారి ఐడిలు రెట్టింపు చేయబడతాయి.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: true },
  { id: 5, name: 'Eve', isActive: false }
];

const processedActiveUsers = users
  .filter(user => user.isActive) // కేవలం యాక్టివ్ యూజర్‌లను పొందండి
  .map((user, index) => ({      // ప్రతి యాక్టివ్ యూజర్‌ను మార్చండి
    name: `${index + 1}. ${user.name}`,
    doubledId: user.id * 2
  }));

console.log(processedActiveUsers);
/* అవుట్‌పుట్:
[
  { name: '1. Alice', doubledId: 2 },
  { name: '2. Charlie', doubledId: 6 },
  { name: '3. David', doubledId: 8 }
]
*/

ఈ చైన్డ్ విధానం డిక్లరేటివ్: మేము స్పష్టమైన లూప్ నిర్వహణ లేకుండా దశలను (ఫిల్టర్, ఆపై మ్యాప్) నిర్దేశిస్తాము. ఇది ఇమ్మ్యూటబుల్ కూడా, ఎందుకంటే ప్రతి దశ ఒక కొత్త అర్రే లేదా ఆబ్జెక్ట్‌ను ఉత్పత్తి చేస్తుంది, అసలు users అర్రేను తాకకుండా వదిలివేస్తుంది.

ఆచరణలో ఇమ్మ్యూటబిలిటీ

ఫంక్షనల్ ప్రోగ్రామింగ్ ఇమ్మ్యూటబిలిటీపై ఎక్కువగా ఆధారపడుతుంది. దీని అర్థం ఇప్పటికే ఉన్న డేటా నిర్మాణాలను మార్చే బదులు, మీరు కావలసిన మార్పులతో కొత్త వాటిని సృష్టిస్తారు. జావాస్క్రిప్ట్ యొక్క map, filter, మరియు slice వంటి అర్రే పద్ధతులు కొత్త అర్రేలను తిరిగి ఇవ్వడం ద్వారా దీనికి స్వాభావికంగా మద్దతు ఇస్తాయి.

ఇమ్మ్యూటబిలిటీ ఎందుకు ముఖ్యమైనది?

మీరు సాంప్రదాయకంగా ఒక అర్రేను మార్చే ఆపరేషన్ (ఒక మూలకాన్ని జోడించడం లేదా తీసివేయడం వంటివి) చేయవలసి వచ్చినప్పుడు, మీరు slice, స్ప్రెడ్ సింటాక్స్ (...), లేదా ఇతర ఫంక్షనల్ పద్ధతులను కలపడం ద్వారా ఇమ్మ్యూటబిలిటీని సాధించవచ్చు.

ఉదాహరణ: ఒక మూలకాన్ని ఇమ్మ్యూటబుల్‌గా జోడించడం

const originalArray = [1, 2, 3];

// ఇంపరేటివ్ విధానం (originalArrayను మారుస్తుంది)
// originalArray.push(4);

// స్ప్రెడ్ సింటాక్స్ ఉపయోగించి ఫంక్షనల్ విధానం
const newArrayWithPush = [...originalArray, 4];
console.log(originalArray); // అవుట్‌పుట్: [1, 2, 3]
console.log(newArrayWithPush); // అవుట్‌పుట్: [1, 2, 3, 4]

// స్లైస్ మరియు కాన్‌కాటినేషన్ ఉపయోగించి ఫంక్షనల్ విధానం (ఇప్పుడు అంత సాధారణం కాదు)
const newArrayWithSlice = originalArray.slice(0, originalArray.length).concat(4);
console.log(newArrayWithSlice); // అవుట్‌పుట్: [1, 2, 3, 4]

ఉదాహరణ: ఒక మూలకాన్ని ఇమ్మ్యూటబుల్‌గా తీసివేయడం

const originalArray = [1, 2, 3, 4, 5];

// ఇండెక్స్ 2 వద్ద ఉన్న మూలకాన్ని (విలువ 3) తీసివేయండి

// స్లైస్ మరియు స్ప్రెడ్ సింటాక్స్ ఉపయోగించి ఫంక్షనల్ విధానం
const newArrayAfterSplice = [
  ...originalArray.slice(0, 2),
  ...originalArray.slice(3)
];
console.log(originalArray); // అవుట్‌పుట్: [1, 2, 3, 4, 5]
console.log(newArrayAfterSplice); // అవుట్‌పుట్: [1, 2, 4, 5]

// ఒక నిర్దిష్ట విలువను తీసివేయడానికి ఫిల్టర్ ఉపయోగించి
const newValueToRemove = 3;
const arrayWithoutValue = originalArray.filter(item => item !== newValueToRemove);
console.log(arrayWithoutValue); // అవుట్‌పుట్: [1, 2, 4, 5]

ఉత్తమ పద్ధతులు మరియు అధునాతన పద్ధతులు

మీరు ఫంక్షనల్ అర్రే పద్ధతులతో మరింత సౌకర్యవంతంగా మారినప్పుడు, ఈ పద్ధతులను పరిగణించండి:

ఉదాహరణ: డేటా అగ్రిగేషన్‌కు ఫంక్షనల్ విధానం

వివిధ ప్రాంతాల నుండి మీకు అమ్మకాల డేటా ఉందని మరియు ప్రతి ప్రాంతానికి మొత్తం అమ్మకాలను లెక్కించి, ఆపై అత్యధిక అమ్మకాలు ఉన్న ప్రాంతాన్ని కనుగొనాలని ఊహించుకోండి.

const salesData = [
  { region: 'North', amount: 100 },
  { region: 'South', amount: 150 },
  { region: 'North', amount: 120 },
  { region: 'East', amount: 200 },
  { region: 'South', amount: 180 },
  { region: 'North', amount: 90 }
];

// 1. reduce ఉపయోగించి ప్రతి ప్రాంతానికి మొత్తం అమ్మకాలను లెక్కించండి
const salesByRegion = salesData.reduce((acc, sale) => {
  acc[sale.region] = (acc[sale.region] || 0) + sale.amount;
  return acc;
}, {});

// salesByRegion ఇలా ఉంటుంది: { North: 310, South: 330, East: 200 }

// 2. సమగ్ర ఆబ్జెక్ట్‌ను తదుపరి ప్రాసెసింగ్ కోసం ఆబ్జెక్ట్‌ల అర్రేగా మార్చండి
const salesArray = Object.keys(salesByRegion).map(region => ({
  region: region,
  totalAmount: salesByRegion[region]
}));

// salesArray ఇలా ఉంటుంది: [
//   { region: 'North', totalAmount: 310 },
//   { region: 'South', totalAmount: 330 },
//   { region: 'East', totalAmount: 200 }
// ]

// 3. reduce ఉపయోగించి అత్యధిక అమ్మకాలు ఉన్న ప్రాంతాన్ని కనుగొనండి
const highestSalesRegion = salesArray.reduce((max, current) => {
  return current.totalAmount > max.totalAmount ? current : max;
}, { region: '', totalAmount: -Infinity }); // చాలా చిన్న సంఖ్యతో ప్రారంభించండి

console.log('ప్రాంతాల వారీగా అమ్మకాలు:', salesByRegion);
console.log('అమ్మకాల అర్రే:', salesArray);
console.log('అత్యధిక అమ్మకాలు ఉన్న ప్రాంతం:', highestSalesRegion);

/*
అవుట్‌పుట్:
ప్రాంతాల వారీగా అమ్మకాలు: { North: 310, South: 330, East: 200 }
అమ్మకాల అర్రే: [
  { region: 'North', totalAmount: 310 },
  { region: 'South', totalAmount: 330 },
  { region: 'East', totalAmount: 200 }
]
అత్యధిక అమ్మకాలు ఉన్న ప్రాంతం: { region: 'South', totalAmount: 330 }
*/

ముగింపు

జావాస్క్రిప్ట్ అర్రేలతో ఫంక్షనల్ ప్రోగ్రామింగ్ కేవలం ఒక శైలీకృత ఎంపిక కాదు; ఇది శుభ్రమైన, మరింత ఊహించదగిన, మరియు మరింత బలమైన కోడ్‌ను వ్రాయడానికి ఒక శక్తివంతమైన మార్గం. map, filter, మరియు reduce వంటి పద్ధతులను స్వీకరించడం ద్వారా, మీరు ఫంక్షనల్ ప్రోగ్రామింగ్ యొక్క ప్రధాన సూత్రాలకు, ముఖ్యంగా ఇమ్మ్యూటబిలిటీ మరియు ప్యూర్ ఫంక్షన్‌లకు కట్టుబడి ఉంటూ మీ డేటాను సమర్థవంతంగా మార్చవచ్చు, ప్రశ్నించవచ్చు మరియు సమగ్రపరచవచ్చు.

మీరు జావాస్క్రిప్ట్ డెవలప్‌మెంట్‌లో మీ ప్రయాణాన్ని కొనసాగిస్తున్నప్పుడు, ఈ ఫంక్షనల్ ప్యాటర్న్‌లను మీ రోజువారీ వర్క్‌ఫ్లోలో ఏకీకృతం చేయడం నిస్సందేహంగా మరింత నిర్వహించదగిన మరియు స్కేలబుల్ అప్లికేషన్‌లకు దారితీస్తుంది. మీ ప్రాజెక్ట్‌లలో ఈ అర్రే పద్ధతులతో ప్రయోగాలు చేయడం ప్రారంభించండి, మరియు మీరు త్వరలోనే వాటి అపారమైన విలువను కనుగొంటారు.