JavaScript Loops

JavaScript லூப்கள் ஒரு குறியீட்டு தொகுதியை பல முறை மீண்டும் மீண்டும் செயல்படுத்துகின்றன.

லூப்கள் பின்வரும் பணிகளுக்கு அடிப்படையானவை:

மதிப்புகள் மீது மீள்வு
தரவு கட்டமைப்புகள் மீது மீள்வு
ஒரு செயலை பல முறை செய்தல்

லூப் வகை	விளக்கம்
`for`	மதிப்புகள் மற்றும் வெளிப்பாடுகள் மீது மீள்வு
`while`	ஒரு நிபந்தனை மீது மீள்வு
`do...while`	ஒரு நிபந்தனை மீது மீள்வு
`for...in`	ஒரு பொருளின் பண்புகள் மீது மீள்வு
`for...of`	வரிசை போன்ற பொருள்கள் மீது மீள்வு
`forEach()`	வரிசையில் உள்ள ஒவ்வொரு உறுப்பு மீது மீள்வு

The for Loop

for லூப் மீள்வுகளின் எண்ணிக்கை தெரிந்திருக்கும் போது பயன்படுத்தப்படுகிறது.

இது ஒரு தொடக்கமாக்கல் (exp1), ஒரு நிபந்தனை (exp2), மற்றும் ஒரு அதிகரிப்பு வெளிப்பாடு (exp3) ஆகியவற்றைக் கொண்டுள்ளது.

Syntax

for (exp1; exp2; exp3) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

exp1 குறியீட்டு தொகுதியின் செயல்பாட்டிற்கு முன்பு ஒரு முறை செயல்படுத்தப்படுகிறது.
exp2 குறியீட்டு தொகுதியை செயல்படுத்துவதற்கான நிபந்தனையை வரையறுக்கிறது.
exp3 ஒரு குறியீட்டு தொகுதி செயல்படுத்தப்பட்ட ஒவ்வொரு முறையும் செயல்படுத்தப்படுகிறது.

Example

for (let i = 0; i < 5; i++) {
  text += "The number is " + i + "<br>";
}

The while Loop

while லூப் ஒரு குறிப்பிட்ட நிபந்தனை true என மதிப்பீடு செய்யும் வரை ஒரு குறியீட்டு தொகுதியை செயல்படுத்துகிறது.

Syntax

while (condition) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

பின்வரும் எடுத்துக்காட்டில், ஒரு மாறி (i) 10 ஐ விடக் குறைவாக இருக்கும் வரை, லூப்பில் உள்ள குறியீடு மீண்டும் மீண்டும் இயங்கும்:

Example

while (i < 10) {
  text += "The number is " + i;
  i++;
}

⚠️ குறிப்பு:

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

The do...while Loop

do...while லூப் while லூப்பைப் போன்றது, ஆனால் நிபந்தனை சரிபார்க்கப்படுவதற்கு முன்பே குறியீட்டு தொகுதி குறைந்தது ஒரு முறை செயல்படுத்தப்படும் என்பதை உறுதி செய்கிறது.

Syntax

do {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}
while (condition);

கீழே உள்ள எடுத்துக்காட்டு do...while லூப்பைப் பயன்படுத்துகிறது. நிபந்தனை false ஆக இருந்தாலும், லூப் குறைந்தது ஒரு முறையாவது செயல்படுத்தப்படும், ஏனெனில் குறியீட்டு தொகுதி நிபந்தனை சோதிக்கப்படுவதற்கு முன்பே செயல்படுத்தப்படுகிறது:

Example

do {
  text += "The number is " + i;
  i++;
}
while (i < 10);

💡 உதவிக்குறிப்பு:

நிபந்தனையில் பயன்படுத்தப்படும் மாறியை அதிகரிப்பதை மறக்காதீர்கள், இல்லையெனில் லூப் ஒருபோதும் முடிவடையாது!

The for...in Loop

for...in லூப் ஒரு பொருளின் எண்ணக்கூடிய பண்புகள் மீது மீள்வு செய்கிறது.

இது பொதுவாக பொருள் விசைகள் மீது மீள்வதற்குப் பயன்படுத்தப்படுகிறது.

Syntax

for (key in object) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

ஒரு JavaScript for...in அறிக்கை ஒரு நபர் பொருளின் பண்புகள் வழியாக லூப் செய்கிறது:

Example

const person = {fname:"John", lname:"Doe", age:25};

let text = "";
for (let x in person) {
  text += person[x];
}

The for...of Loop

for...of லூப் வரிசைகள், சரங்கள், Maps, Sets மற்றும் NodeLists போன்ற மீளக்கூடிய பொருள்களின் மதிப்புகள் மீது மீள்வு செய்கிறது.

Syntax

for (variable of iterable) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

variable: ஒவ்வொரு மீள்விற்கும் அடுத்த பண்பின் மதிப்பு மாறிக்கு ஒதுக்கப்படுகிறது. மாறியை const, let, அல்லது var உடன் அறிவிக்கலாம்.
iterable: மீளக்கூடிய பண்புகளைக் கொண்ட ஒரு பொருள்.

Other Methods

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

forEach() முறை

வரிசையில் உள்ள ஒவ்வொரு உறுப்புக்கும் ஒரு செயல்பாட்டை செயல்படுத்துகிறது

map() முறை

ஒரு புதிய வரிசையை உருவாக்குகிறது, ஒவ்வொரு உறுப்பிலும் ஒரு செயல்பாட்டை அழைத்து

filter() முறை

ஒரு நிபந்தனையை பூர்த்தி செய்யும் உறுப்புகளுடன் ஒரு புதிய வரிசையை உருவாக்குகிறது

JavaScript Loops பயிற்சி

JavaScript லூப்களைப் பற்றிய உங்கள் அறிவைச் சோதிக்க இந்த பயிற்சியை முயற்சிக்கவும்.

❓ பின்வருவனவற்றில் எது 0 முதல் 4 வரை எண்களை அச்சிடும் சரியான for லூப்?

for (let i = 0; i <= 5; i++)

✗ தவறு! இது 0 முதல் 5 வரை அச்சிடும் (6 எண்கள்)

for (let i = 1; i < 5; i++)

✗ தவறு! இது 1, 2, 3, 4 ஐ மட்டுமே அச்சிடும் (0 இல்லை)

for (let i = 0; i < 5; i++)

✓ சரி! இந்த லூப் 0, 1, 2, 3, 4 ஆகிய 5 எண்களை அச்சிடும்

for (let i = 0; i > 5; i++)

✗ தவறு! இந்த நிபந்தனை false ஆகும், எனவே லூப் ஒருபோதும் இயங்காது