M

MLOG

தமிழ்

ஜாவாஸ்கிரிப்ட் அரேக்களுடன் ஃபங்ஷனல் புரோகிராமிங்கின் ஆற்றலைத் திறந்திடுங்கள். உள்ளமைக்கப்பட்ட மெத்தடுகளைப் பயன்படுத்தி உங்கள் தரவை திறமையாக மாற்ற, வடிகட்ட மற்றும் குறைக்க கற்றுக்கொள்ளுங்கள்.

ஜாவாஸ்கிரிப்ட் அரேக்களுடன் ஃபங்ஷனல் புரோகிராமிங்கில் தேர்ச்சி பெறுதல்

வலை மேம்பாட்டின் எப்போதும் மாறிவரும் நிலப்பரப்பில், ஜாவாஸ்கிரிப்ட் ஒரு மூலக்கல்லாக தொடர்கிறது. ஆப்ஜெக்ட்-ஓரியண்டட் மற்றும் இம்பரேட்டிவ் புரோகிராமிங் முன்னுதாரணங்கள் நீண்ட காலமாக ஆதிக்கம் செலுத்தி வந்தாலும், ஃபங்ஷனல் புரோகிராமிங் (FP) குறிப்பிடத்தக்க கவனத்தைப் பெற்று வருகிறது. FP இம்யூட்டபிலிட்டி, தூய செயல்பாடுகள், மற்றும் அறிவிப்பு முறையிலான குறியீட்டை வலியுறுத்துகிறது, இது மிகவும் வலுவான, பராமரிக்கக்கூடிய, மற்றும் கணிக்கக்கூடிய பயன்பாடுகளுக்கு வழிவகுக்கிறது. ஜாவாஸ்கிரிப்டில் ஃபங்ஷனல் புரோகிராமிங்கைத் தழுவுவதற்கான மிக சக்திவாய்ந்த வழிகளில் ஒன்று அதன் இயல்பான அரே மெத்தடுகளைப் பயன்படுத்துவதாகும்.

இந்த விரிவான வழிகாட்டி, ஜாவாஸ்கிரிப்ட் அரேக்களைப் பயன்படுத்தி ஃபங்ஷனல் புரோகிராமிங் கொள்கைகளின் ஆற்றலை நீங்கள் எவ்வாறு பயன்படுத்தலாம் என்பதை ஆராயும். நாங்கள் முக்கிய கருத்துக்களை ஆராய்ந்து, map, filter, மற்றும் reduce போன்ற மெத்தடுகளைப் பயன்படுத்தி அவற்றை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குவோம், இது நீங்கள் தரவு கையாளுதலைக் கையாளும் விதத்தை மாற்றியமைக்கும்.

ஃபங்ஷனல் புரோகிராமிங் என்றால் என்ன?

ஜாவாஸ்கிரிப்ட் அரேக்களுக்குள் செல்வதற்கு முன், ஃபங்ஷனல் புரோகிராமிங்கை சுருக்கமாக வரையறுப்போம். அதன் மையத்தில், FP என்பது கணக்கீட்டை கணித செயல்பாடுகளின் மதிப்பீடாகக் கருதும் ஒரு புரோகிராமிங் முன்னுதாரணமாகும், மேலும் இது நிலையை மாற்றுவதையும் மாற்றக்கூடிய தரவையும் தவிர்க்கிறது. முக்கிய கொள்கைகள் பின்வருமாறு:

இந்தக் கொள்கைகளை ஏற்றுக்கொள்வது, குறிப்பாக சிக்கலான பயன்பாடுகளில், பகுத்தறிவு, சோதனை மற்றும் பிழைத்திருத்தம் செய்வதற்கு எளிதான குறியீட்டிற்கு வழிவகுக்கும். ஜாவாஸ்கிரிப்டின் அரே மெத்தடுகள் இந்தக் கருத்துக்களைச் செயல்படுத்த hoàn hảoంగాப் பொருத்தமானவை.

ஜாவாஸ்கிரிப்ட் அரே மெத்தடுகளின் ஆற்றல்

ஜாவாஸ்கிரிப்ட் அரேக்கள், பாரம்பரிய லூப்களை (for அல்லது while போன்றவை) நாடாமல், மேம்பட்ட தரவு கையாளுதலுக்கு அனுமதிக்கும் உள்ளமைக்கப்பட்ட மெத்தடுகளின் வளமான தொகுப்புடன் வருகின்றன. இந்த மெத்தடுகள் பெரும்பாலும் புதிய அரேக்களைத் திருப்பித் தருகின்றன, இம்யூட்டபிலிட்டியயை ஊக்குவிக்கின்றன, மற்றும் கால்பேக் செயல்பாடுகளை ஏற்றுக்கொள்கின்றன, இது ஒரு ஃபங்ஷனல் அணுகுமுறையை செயல்படுத்துகிறது.

மிகவும் அடிப்படையான ஃபங்ஷனல் அரே மெத்தடுகளை ஆராய்வோம்:

1. Array.prototype.map()

map() மெத்தட், அழைக்கப்படும் அரேவில் உள்ள ஒவ்வொரு உறுப்பின் மீதும் வழங்கப்பட்ட செயல்பாட்டை அழைப்பதன் முடிவுகளுடன் நிரப்பப்பட்ட ஒரு புதிய அரேவை உருவாக்குகிறது. ஒரு அரேவின் ஒவ்வொரு உறுப்பையும் புதியதாக மாற்றுவதற்கு இது சிறந்தது.

தொடரியல்:

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

முக்கிய பண்புகள்:

உதாரணம்: ஒவ்வொரு எண்ணையும் இரட்டிப்பாக்குதல்

உங்களிடம் எண்களின் அரே இருப்பதாகவும், ஒவ்வொரு எண்ணும் இரட்டிப்பாக்கப்பட்ட ஒரு புதிய அரேவை உருவாக்க விரும்புகிறீர்கள் என்றும் கற்பனை செய்து பாருங்கள்.

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

// உருமாற்றத்திற்காக map ஐப் பயன்படுத்துதல்
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];

// இரட்டைப்படை எண்களைத் தேர்ந்தெடுக்க filter ஐப் பயன்படுத்துதல்
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() மெத்தட், அரேவின் ஒவ்வொரு உறுப்பின் மீதும் பயனர் வழங்கிய “reducer” கால்பேக் செயல்பாட்டை வரிசையாகச் செயல்படுத்துகிறது, முந்தைய உறுப்பின் கணக்கீட்டிலிருந்து வரும் ரிட்டர்ன் மதிப்பை உள்ளீடாகப் பெறுகிறது. அரேவின் அனைத்து உறுப்புகளிலும் reducer-ஐ இயக்கியதன் இறுதி முடிவு ஒரு ஒற்றை மதிப்பாகும்.

இது அரே மெத்தடுகளில் மிகவும் பல்துறை வாய்ந்தது மற்றும் பல ஃபங்ஷனல் புரோகிராமிங் பேட்டர்ன்களின் மூலக்கல்லாகும், இது ஒரு அரேவை ஒரு ஒற்றை மதிப்பிற்கு (எ.கா., கூட்டுத்தொகை, பெருக்கல், எண்ணிக்கை, அல்லது ஒரு புதிய ஆப்ஜெக்ட் அல்லது அரே) “குறைக்க” உங்களை அனுமதிக்கிறது.

தொடரியல்:

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 (ஏனென்றால் Bob செயலிழந்துள்ளார்)
console.log(allAreActive); // வெளியீடு: false (ஏனென்றால் Bob செயலிழந்துள்ளார்)

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 }
]
*/

இந்த சங்கிலித்தொடர் அணுகுமுறை அறிவிப்பு முறையானது: வெளிப்படையான லூப் மேலாண்மை இல்லாமல் படிகளை (வடிகட்டுதல், பின்னர் map) நாங்கள் குறிப்பிடுகிறோம். இது இம்யூட்டபிள் ஆகும், ஏனெனில் ஒவ்வொரு படியும் ஒரு புதிய அரே அல்லது ஆப்ஜெக்டை உருவாக்குகிறது, அசல் 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]

// slice மற்றும் concatenation ஐப் பயன்படுத்தி ஃபங்ஷனல் வழி (இப்போது குறைவாகப் பயன்படுத்தப்படுகிறது)
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)

// slice மற்றும் ஸ்ப்ரெட் சிண்டாக்ஸைப் பயன்படுத்தி ஃபங்ஷனல் வழி
const newArrayAfterSplice = [
  ...originalArray.slice(0, 2),
  ...originalArray.slice(3)
];
console.log(originalArray); // வெளியீடு: [1, 2, 3, 4, 5]
console.log(newArrayAfterSplice); // வெளியீடு: [1, 2, 4, 5]

// ஒரு குறிப்பிட்ட மதிப்பை அகற்ற filter ஐப் பயன்படுத்துதல்
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('Sales by Region:', salesByRegion);
console.log('Sales Array:', salesArray);
console.log('Region with Highest Sales:', highestSalesRegion);

/*
வெளியீடு:
Sales by Region: { North: 310, South: 330, East: 200 }
Sales Array: [
  { region: 'North', totalAmount: 310 },
  { region: 'South', totalAmount: 330 },
  { region: 'East', totalAmount: 200 }
]
Region with Highest Sales: { region: 'South', totalAmount: 330 }
*/

முடிவுரை

ஜாவாஸ்கிரிப்ட் அரேக்களுடன் ஃபங்ஷனல் புரோகிராமிங் என்பது ஒரு ஸ்டைலிஸ்டிக் தேர்வு மட்டுமல்ல; இது தூய்மையான, கணிக்கக்கூடிய, மற்றும் வலுவான குறியீட்டை எழுதுவதற்கான ஒரு சக்திவாய்ந்த வழியாகும். map, filter, மற்றும் reduce போன்ற மெத்தடுகளைத் தழுவுவதன் மூலம், நீங்கள் ஃபங்ஷனல் புரோகிராமிங்கின் முக்கிய கொள்கைகளான இம்யூட்டபிலிட்டி மற்றும் தூய செயல்பாடுகளைக் கடைப்பிடிக்கும்போது உங்கள் தரவை திறம்பட மாற்ற, வினவ மற்றும் திரட்ட முடியும்.

ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் உங்கள் பயணத்தைத் தொடரும்போது, இந்த ஃபங்ஷனல் பேட்டர்ன்களை உங்கள் தினசரி பணிப்பாய்வுகளில் ஒருங்கிணைப்பது சந்தேகத்திற்கு இடமின்றி மேலும் பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய பயன்பாடுகளுக்கு வழிவகுக்கும். உங்கள் திட்டங்களில் இந்த அரே மெத்தடுகளைப் பரிசோதிப்பதன் மூலம் தொடங்குங்கள், விரைவில் அவற்றின் மகத்தான மதிப்பை நீங்கள் கண்டுபிடிப்பீர்கள்.