JavaScript Loops

JavaScript லூப்களைக் கற்றுக்கொள்ளுங்கள்

JavaScript லூப்கள்

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

நீங்கள் ஒரே குறியீட்டை மீண்டும் மீண்டும் இயக்க விரும்பினால், ஒவ்வொரு முறையும் வெவ்வேறு மதிப்புடன், லூப்கள் பயனுள்ளதாக இருக்கும்.

🔄 வரிசைகளுடன் பணிபுரியும் போது:

வரிசைகளுடன் பணிபுரியும் போது பெரும்பாலும் இந்த வழக்கு ஏற்படுகிறது:

லூப் இல்லாமல்

text += cars[0] + "
";
text += cars[1] + "
";
text += cars[2] + "
";
text += cars[3] + "
";
text += cars[4] + "
";
text += cars[5] + "
";

லூப் உடன்

for (let i = 0; i < cars.length; i++) {
  text += cars[i] + "
";
}

For லூப்

for அறிக்கை 3 விருப்ப வெளிப்பாடுகளுடன் ஒரு லூப்பை உருவாக்குகிறது:

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

expr1

குறியீட்டுத் தொகுதியின் செயல்பாட்டிற்கு முன் ஒரு முறை செயல்படுத்தப்படுகிறது

expr2

குறியீட்டுத் தொகுதியை செயல்படுத்துவதற்கான நிபந்தனையை வரையறுக்கிறது

expr3

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

எடுத்துக்காட்டு

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

expr1

லூப் தொடங்குவதற்கு முன் ஒரு மாறியை அமைக்கிறது (let i = 0)

expr2

லூப்பை இயக்குவதற்கான நிபந்தனையை வரையறுக்கிறது (i 5 ஐ விடக் குறைவாக இருக்க வேண்டும்)

expr3

குறியீட்டுத் தொகுதி செயல்படுத்தப்பட்ட ஒவ்வொரு முறையும் ஒரு மதிப்பை அதிகரிக்கிறது (i++)

லூப் நோக்கம்

எடுத்துக்காட்டு 1

let i = 5;

for (i = 0; i < 10; i++) {
  // சில குறியீடு
}

// இங்கே i 10 ஆகும்

எடுத்துக்காட்டு 2

let i = 5;

for (let i = 0; i < 10; i++) {
  // சில குறியீடு
}

// இங்கே i 5 ஆகும்

🎯 நோக்கம் விளக்கம்:

  • முதல் எடுத்துக்காட்டில், let i = 5; லூப்பிற்கு வெளியே அறிவிக்கப்படுகிறது
  • இரண்டாவது எடுத்துக்காட்டில், let i = 0; லூப்பின் உள்ளே அறிவிக்கப்படுகிறது
  • ஒரு மாறி let அல்லது const உடன் ஒரு லூப்பிற்குள் அறிவிக்கப்படும்போது, அது லூப்பிற்குள் மட்டுமே தெரியும்

While லூப்

while லூப் ஒரு குறிப்பிட்ட நிபந்தனை உண்மையாக இருக்கும் வரை ஒரு குறியீட்டுத் தொகுதியின் வழியாக வளையமிடுகிறது.

தொடரியல்

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

எடுத்துக்காட்டு

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

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

⚠️ கவனத்திற்கு:

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

Do While லூப்

do while லூப் என்பது while லூப்பின் ஒரு மாறுபாடு ஆகும்.

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

தொடரியல்

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

🔄 முக்கிய வேறுபாடு:

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

எடுத்துக்காட்டு

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

⚠️ கவனத்திற்கு:

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

லூப் ஒப்பீடு

லூப் வகை பயன்பாடு முன்-நிபந்தனை சோதனை குறைந்தபட்ச செயல்பாடுகள்
for லூப் குறிப்பிட்ட எண்ணிக்கையிலான மறு செய்கைகளுக்கு ஆம் 0 முறை
while லூப் நிபந்தனை உண்மையாக இருக்கும் வரை ஆம் 0 முறை
do...while லூப் குறைந்தபட்சம் ஒரு முறை, பின்னர் நிபந்தனை உண்மையாக இருக்கும் வரை இல்லை 1 முறை

For லூப்

நீங்கள் எத்தனை முறை வளையமிட விரும்புகிறீர்கள் என்பதை அறிந்திருக்கும் போது

While லூப்

நீங்கள் எத்தனை முறை வளையமிட வேண்டும் என்பது தெரியாதபோது

Do...While லூப்

குறைந்தபட்சம் ஒரு முறையாவது குறியீட்டை இயக்க வேண்டியிருக்கும் போது

பயிற்சி

❓ பின்வரும் while லூப்பைக் கவனியுங்கள்:

let i = 0;
while (i < 5) {
  console.log("Number: " + i);
  i++;
}

இந்த லூப் எத்தனை முறை இயங்கும்?

4 முறை
✗ தவறு! i 0 இலிருந்து தொடங்குகிறது, மேலும் i < 5 வரை இயங்கும். இது i = 0,1,2,3,4 ஆக இருக்கும் போது இயங்கும், இது 5 முறைகள் ஆகும்
5 முறை
✓ சரி! while லூப் i = 0, 1, 2, 3, மற்றும் 4 ஆக இருக்கும் போது இயங்கும். i 5 ஆக மாறும்போது, நிபந்தனை (i < 5) false ஆக மாறுகிறது, எனவே லூப் நிறுத்தப்படுகிறது. இது மொத்தம் 5 முறை இயங்குகிறது
6 முறை
✗ தவறு! லூப் i = 5 ஆக மாறும்போது நிறுத்தப்படுகிறது, ஏனெனில் நிபந்தனை (i < 5) false ஆகிறது. இது i = 0,1,2,3,4 ஆக இருக்கும் போது மட்டுமே இயங்குகிறது
முடிவில்லாமல்
✗ தவறு! லூப்பிற்குள் i++ உள்ளது, இது ஒவ்வொரு மறு செய்கையிலும் i ஐ அதிகரிக்கிறது. i 5 ஆக மாறும்போது, நிபந்தனை தவறானது, எனவே லூப் முடிவடைகிறது