ஒவ்வொரு டெவலப்பரும் தேர்ச்சி பெற வேண்டிய Array முறைகள்

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

ஏன் அரே முறைகளில் தேர்ச்சி பெற வேண்டும்?

• திறன்: அரே முறைகள் அரேக்களில் பொதுவான செயல்பாடுகளைச் செய்ய உகந்த மற்றும் சுருக்கமான வழிகளை வழங்குகின்றன.
• வாசிப்புத்தன்மை: உள்ளமைக்கப்பட்ட முறைகளைப் பயன்படுத்துவது உங்கள் குறியீட்டைப் புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்குகிறது.
• செயல்பாட்டு நிரலாக்கம் (Functional Programming): பல அரே முறைகள் செயல்பாட்டு நிரலாக்க பாணியை ஊக்குவிக்கின்றன, இது தூய்மையான மற்றும் சோதிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது.
• பல உலாவி இணக்கத்தன்மை: ஜாவாஸ்கிரிப்ட் அரே முறைகள் நவீன உலாவிகளில் பரவலாக ஆதரிக்கப்படுகின்றன.

அத்தியாவசிய அரே முறைகள்

1. அரேக்களை வரிசைப்படுத்துதல்: forEach()

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

தொடரியல்:

array.forEach(function(currentValue, index, array) {
  // ஒவ்வொரு உறுப்புக்கும் செயல்படுத்த வேண்டிய குறியீடு
});

உதாரணம்:

const numbers = [1, 2, 3, 4, 5];
numbers.forEach(number => {
  console.log(number * 2);
});
// வெளியீடு: 2, 4, 6, 8, 10

பயன்பாடு: ஒரு பட்டியலில் உள்ள உருப்படிகளைக் காண்பித்தல், அரே உறுப்புகளின் பண்புகளைப் புதுப்பித்தல்.

2. அரேக்களை மாற்றுதல்: map()

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

தொடரியல்:

const newArray = array.map(function(currentValue, index, array) {
  // மாற்றப்பட்ட மதிப்பைத் திருப்பவும்
});

உதாரணம்:

const numbers = [1, 2, 3, 4, 5];
const squaredNumbers = numbers.map(number => number * number);
console.log(squaredNumbers);
// வெளியீடு: [1, 4, 9, 16, 25]

பயன்பாடு: காட்சிப்படுத்துவதற்கான தரவை வடிவமைத்தல், அலகுகளை மாற்றுதல், மாற்றியமைக்கப்பட்ட மதிப்புகளுடன் ஒரு புதிய அரேவை உருவாக்குதல்.

உலகளாவிய உதாரணம்: உங்களிடம் USD இல் நாணய மதிப்புகளின் ஒரு அரே உள்ளது என்று கற்பனை செய்து பாருங்கள், அவற்றை EUR ஆக மாற்ற வேண்டும். EUR மதிப்புகளின் புதிய அரேவை உருவாக்க, பரிமாற்ற வீத API உடன் map() ஐப் பயன்படுத்தலாம்.

3. அரேக்களை வடிகட்டுதல்: filter()

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

தொடரியல்:

const newArray = array.filter(function(currentValue, index, array) {
  // உறுப்பை வைத்திருக்க true, விலக்க false எனத் திருப்பவும்
});

உதாரணம்:

const numbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = numbers.filter(number => number % 2 === 0);
console.log(evenNumbers);
// வெளியீடு: [2, 4, 6]

பயன்பாடு: தேவையற்ற தரவை நீக்குதல், தேடல் அளவுகோல்களின் அடிப்படையில் உருப்படிகளைத் தேர்ந்தெடுத்தல், பயனர் விருப்பங்களின் அடிப்படையில் தரவை வடிகட்டுதல்.

உலகளாவிய உதாரணம்: வெவ்வேறு நாடுகளைச் சேர்ந்த பயனர் பொருட்களின் ஒரு அரேவைக் கவனியுங்கள். "ஜப்பான்" அல்லது "பிரேசில்" போன்ற ஒரு குறிப்பிட்ட நாட்டிலிருந்து பயனர்களை மட்டும் கொண்ட ஒரு புதிய அரேவை உருவாக்க நீங்கள் filter() ஐப் பயன்படுத்தலாம்.

4. அரேக்களைக் குறைத்தல்: reduce()

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

தொடரியல்:

const result = array.reduce(function(accumulator, currentValue, currentIndex, array) {
  // புதுப்பிக்கப்பட்ட accumulator-ஐத் திருப்பவும்
}, initialValue);

உதாரணம்:

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum);
// வெளியீடு: 15

பயன்பாடு: கூட்டுத்தொகை, சராசரிகளைக் கணக்கிடுதல், அதிகபட்ச அல்லது குறைந்தபட்ச மதிப்புகளைக் கண்டறிதல், சரங்களை இணைத்தல்.

உலகளாவிய உதாரணம்: வெவ்வேறு பிராந்தியங்களிலிருந்து (எ.கா., வட அமெரிக்கா, ஐரோப்பா, ஆசியா) விற்பனை புள்ளிவிவரங்களின் ஒரு அரே உங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். மொத்த உலகளாவிய விற்பனையைக் கணக்கிட நீங்கள் reduce() ஐப் பயன்படுத்தலாம்.

5. அரேக்களைத் தேடுதல்: find(), findIndex(), includes(), indexOf(), lastIndexOf()

ஜாவாஸ்கிரிப்ட் அரேக்களைத் தேடுவதற்கு பல முறைகளை வழங்குகிறது:

• find(): கொடுக்கப்பட்ட சோதனைச் செயல்பாட்டை திருப்திப்படுத்தும் அரேவில் உள்ள முதல் உறுப்பின் மதிப்பைத் திருப்புகிறது. எந்த உறுப்பும் செயல்பாட்டை திருப்திப்படுத்தவில்லை என்றால் undefined ஐத் திருப்புகிறது.
• findIndex(): கொடுக்கப்பட்ட சோதனைச் செயல்பாட்டை திருப்திப்படுத்தும் அரேவில் உள்ள முதல் உறுப்பின் குறியீட்டைத் திருப்புகிறது. எந்த உறுப்பும் செயல்பாட்டை திருப்திப்படுத்தவில்லை என்றால் -1 ஐத் திருப்புகிறது.
• includes(): ஒரு அரே அதன் உள்ளீடுகளில் ஒரு குறிப்பிட்ட மதிப்பைக் கொண்டுள்ளதா என்பதைத் தீர்மானித்து, true அல்லது false ஐத் திருப்புகிறது.
• indexOf(): கொடுக்கப்பட்ட உறுப்பு அரேவில் காணப்படும் முதல் குறியீட்டைத் திருப்புகிறது, அல்லது அது இல்லை என்றால் -1 ஐத் திருப்புகிறது.
• lastIndexOf(): கொடுக்கப்பட்ட உறுப்பு அரேவில் காணப்படும் கடைசி குறியீட்டைத் திருப்புகிறது, அல்லது அது இல்லை என்றால் -1 ஐத் திருப்புகிறது.

உதாரணங்கள்:

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

const foundNumber = numbers.find(number => number > 3);
console.log(foundNumber); // வெளியீடு: 4

const foundIndex = numbers.findIndex(number => number > 3);
console.log(foundIndex); // வெளியீடு: 3

const includesThree = numbers.includes(3);
console.log(includesThree); // வெளியீடு: true

const indexOfTwo = numbers.indexOf(2);
console.log(indexOfTwo); // வெளியீடு: 1

const lastIndexOfFour = [1, 2, 3, 4, 4, 5].lastIndexOf(4);
console.log(lastIndexOfFour); // வெளியீடு: 4

பயன்பாடுகள்: ஒரு பட்டியலில் ஒரு குறிப்பிட்ட பயனரைக் கண்டறிதல், ஒரு ஷாப்பிங் கார்ட்டில் ஒரு பொருள் உள்ளதா எனச் சரிபார்த்தல், ஒரு அரேவில் ஒரு உறுப்பின் நிலையை அறிதல்.

6. உறுப்புகளைச் சேர்த்தல் மற்றும் நீக்குதல்: push(), pop(), shift(), unshift(), splice()

இந்த முறைகள் உறுப்புகளைச் சேர்ப்பதன் மூலமோ அல்லது நீக்குவதன் மூலமோ அசல் அரேவை மாற்றியமைக்கின்றன:

• push(): ஒன்று அல்லது அதற்கு மேற்பட்ட உறுப்புகளை ஒரு அரேவின் இறுதியில் சேர்த்து, அரேவின் புதிய நீளத்தைத் திருப்புகிறது.
• pop(): ஒரு அரேவிலிருந்து கடைசி உறுப்பை நீக்கி, அந்த உறுப்பைத் திருப்புகிறது.
• shift(): ஒரு அரேவிலிருந்து முதல் உறுப்பை நீக்கி, அந்த உறுப்பைத் திருப்புகிறது.
• unshift(): ஒன்று அல்லது அதற்கு மேற்பட்ட உறுப்புகளை ஒரு அரேவின் தொடக்கத்தில் சேர்த்து, அரேவின் புதிய நீளத்தைத் திருப்புகிறது.
• splice(): இருக்கும் உறுப்புகளை நீக்குவதன் மூலம் அல்லது மாற்றுவதன் மூலம் மற்றும்/அல்லது புதிய உறுப்புகளை இடத்திலேயே சேர்ப்பதன் மூலம் ஒரு அரேவின் உள்ளடக்கங்களை மாற்றுகிறது.

உதாரணங்கள்:

const numbers = [1, 2, 3];

numbers.push(4, 5); // இறுதியில் 4 மற்றும் 5 ஐ சேர்க்கிறது
console.log(numbers); // வெளியீடு: [1, 2, 3, 4, 5]

const lastElement = numbers.pop(); // கடைசி உறுப்பை (5) நீக்குகிறது
console.log(numbers); // வெளியீடு: [1, 2, 3, 4]
console.log(lastElement); // வெளியீடு: 5

const firstElement = numbers.shift(); // முதல் உறுப்பை (1) நீக்குகிறது
console.log(numbers); // வெளியீடு: [2, 3, 4]
console.log(firstElement); // வெளியீடு: 1

numbers.unshift(0); // தொடக்கத்தில் 0 ஐ சேர்க்கிறது
console.log(numbers); // வெளியீடு: [0, 2, 3, 4]

numbers.splice(1, 2, 10, 20); // குறியீடு 1-இல் தொடங்கி 2 உறுப்புகளை நீக்கி, 10 மற்றும் 20 ஐச் செருகுகிறது
console.log(numbers); // வெளியீடு: [0, 10, 20, 4]

பயன்பாடுகள்: ஒரு வரிசையை நிர்வகித்தல், ஒரு ஷாப்பிங் கார்ட்டில் பொருட்களைச் சேர்த்தல், பணிகளின் பட்டியலைப் புதுப்பித்தல்.

7. துணை-அரேக்களை உருவாக்குதல்: slice()

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

தொடரியல்:

const newArray = array.slice(start, end);

உதாரணம்:

const numbers = [1, 2, 3, 4, 5];
const subarray = numbers.slice(1, 4);
console.log(subarray); // வெளியீடு: [2, 3, 4]
console.log(numbers); // வெளியீடு: [1, 2, 3, 4, 5] (அசல் அரே மாறாமல் உள்ளது)

பயன்பாடு: செயலாக்கத்திற்காக ஒரு அரேவின் ஒரு பகுதியை பிரித்தெடுத்தல், ஒரு அரேவின் நகலை உருவாக்குதல்.

8. அரேக்களை வரிசைப்படுத்துதல்: sort()

sort() முறையானது ஒரு அரேவின் உறுப்புகளை இடத்திலேயே வரிசைப்படுத்தி, வரிசைப்படுத்தப்பட்ட அரேவைத் திருப்புகிறது. இயல்புநிலை வரிசை ஏறுவரிசையாகும், இது உறுப்புகளை சரங்களாக மாற்றி, பின்னர் அவற்றின் UTF-16 குறியீட்டு அலகுகளின் மதிப்புகளின் வரிசைகளை ஒப்பிடுவதன் மூலம் உருவாக்கப்பட்டது.

தொடரியல்:

array.sort(compareFunction);

compareFunction என்பது விருப்பமானது. தவிர்க்கப்பட்டால், அரே உறுப்புகள் சரங்களாக மாற்றப்பட்டு UTF-16 குறியீட்டு அலகு மதிப்புக்கு ஏற்ப வரிசைப்படுத்தப்படும். எண்களை எண் ரீதியாக வரிசைப்படுத்த விரும்பினால், நீங்கள் ஒரு ஒப்பீட்டுச் செயல்பாட்டை வழங்க வேண்டும்.

உதாரணங்கள்:

const numbers = [3, 1, 4, 1, 5, 9, 2, 6];
numbers.sort(); // அகர வரிசைப்படி வரிசைப்படுத்துகிறது (எண்களை சரங்களாகக் கருதி)
console.log(numbers); // வெளியீடு: [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort((a, b) => a - b); // எண் ரீதியாக வரிசைப்படுத்துகிறது (ஏறுவரிசை)
console.log(numbers); // வெளியீடு: [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort((a, b) => b - a); // எண் ரீதியாக வரிசைப்படுத்துகிறது (இறங்குவரிசை)
console.log(numbers); // வெளியீடு: [9, 6, 5, 4, 3, 2, 1, 1]

பயன்பாடு: தயாரிப்புகளின் பட்டியலை விலை அடிப்படையில் வரிசைப்படுத்துதல், பயனர்களை பெயர் அடிப்படையில் வரிசைப்படுத்துதல், பணிகளை முன்னுரிமை அடிப்படையில் வரிசைப்படுத்துதல்.

9. அரே உறுப்புகளைச் சோதித்தல்: every(), some()

இந்த முறைகள் ஒரு அரேவில் உள்ள அனைத்து அல்லது சில உறுப்புகள் ஒரு நிபந்தனையை திருப்திப்படுத்துகின்றனவா என்பதைச் சோதிக்கின்றன:

• every(): அரேவில் உள்ள அனைத்து உறுப்புகளும் கொடுக்கப்பட்ட செயல்பாட்டின் மூலம் செயல்படுத்தப்பட்ட சோதனையில் தேர்ச்சி பெறுகின்றனவா என்பதைச் சோதிக்கிறது. இது ஒரு பூலியன் மதிப்பைத் திருப்புகிறது.
• some(): அரேவில் உள்ள குறைந்தபட்சம் ஒரு உறுப்பாவது கொடுக்கப்பட்ட செயல்பாட்டின் மூலம் செயல்படுத்தப்பட்ட சோதனையில் தேர்ச்சி பெறுகிறதா என்பதைச் சோதிக்கிறது. அரேவில், கொடுக்கப்பட்ட செயல்பாடு true எனத் திருப்பும் ஒரு உறுப்பைக் கண்டால் அது true ஐத் திருப்புகிறது; இல்லையெனில் அது false ஐத் திருப்புகிறது. இது அரேவை மாற்றாது.

உதாரணங்கள்:

const numbers = [2, 4, 6, 8, 10];

const allEven = numbers.every(number => number % 2 === 0);
console.log(allEven); // வெளியீடு: true

const someOdd = numbers.some(number => number % 2 !== 0);
console.log(someOdd); // வெளியீடு: false

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

10. அரே உறுப்புகளைச் சேர்த்தல்: join()

join() முறையானது ஒரு அரேவில் (அல்லது அரே போன்ற பொருள்) உள்ள அனைத்து உறுப்புகளையும் இணைத்து, காற்புள்ளிகள் அல்லது ஒரு குறிப்பிட்ட பிரிப்பான் சரத்தால் பிரிக்கப்பட்டு ஒரு புதிய சரத்தை உருவாக்கித் திருப்புகிறது. அரேவில் ஒரே ஒரு உருப்படி மட்டுமே இருந்தால், அந்த உருப்படி பிரிப்பானைப் பயன்படுத்தாமல் திருப்பப்படும்.

தொடரியல்:

const newString = array.join(separator);

உதாரணம்:

const words = ["Hello", "World", "!"];
const sentence = words.join(" ");
console.log(sentence); // வெளியீடு: Hello World !

பயன்பாடு: மதிப்புகளின் காற்புள்ளியால் பிரிக்கப்பட்ட பட்டியலை உருவாக்குதல், பிரிவுகளின் அரேவிலிருந்து ஒரு URL பாதையை உருவாக்குதல்.

சிறந்த நடைமுறைகள்

• திரும்பும் மதிப்பை புரிந்து கொள்ளுங்கள்: ஒவ்வொரு முறையும் என்ன திருப்புகிறது (ஒரு புதிய அரே, ஒரு ஒற்றை மதிப்பு, ஒரு பூலியன் போன்றவை) என்பதை அறிந்திருங்கள்.
• மாறாத்தன்மை (Immutability): map(), filter(), மற்றும் slice() போன்ற முறைகள் புதிய அரேக்களை உருவாக்குகின்றன, அசல் தரவைப் பாதுகாக்கின்றன. எதிர்பாராத பக்க விளைவுகளைத் தவிர்க்க, முடிந்தவரை அசல் அரேவை மாற்றும் முறைகளுக்குப் (push(), pop(), shift(), unshift(), splice(), sort()) பதிலாக இவற்றை விரும்புங்கள்.
• சங்கிலித் தொடராக்கல் (Chaining): சிக்கலான செயல்பாடுகளை சுருக்கமாகவும் வாசிக்கக்கூடிய வகையிலும் செய்ய பல அரே முறைகளை இணைக்கவும். உதாரணமாக:

  const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  const result = numbers
    .filter(number => number % 2 === 0) // இரட்டைப்படை எண்களை வடிகட்டவும்
    .map(number => number * 2); // 2 ஆல் பெருக்கவும்
  console.log(result); // வெளியீடு: [4, 8, 12, 16, 20]

• செயல்திறன்: அரே முறைகள் பொதுவாக திறமையானவை என்றாலும், மிக பெரிய அரேக்களுடன் பணிபுரியும் போது செயல்திறன் தாக்கங்களைக் கருத்தில் கொள்ளுங்கள். சில சமயங்களில், ஒரு பாரம்பரிய for லூப் வேகமாக இருக்கலாம்.
• வாசிப்புத்தன்மை: உங்கள் நோக்கத்தை சிறப்பாக வெளிப்படுத்தும் முறையைத் தேர்வு செய்யவும். உதாரணமாக, எளிய வரிசைப்படுத்தலுக்கு forEach(), மாற்றத்திற்கு map(), மற்றும் தேர்வுக்கு filter() ஐப் பயன்படுத்தவும்.

முடிவுரை

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

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