வளையத்திற்கு

1. லூப்களை ஒப்பிடுதல்: forvswhile

ஒரு ஸ்டெட்மெண்ட் அல்லது ஸ்டேட்மெண்ட்களின் குழு பல முறை செய்ய வேண்டிய இடத்தில் ஒரு whileலூப்பைப் பயன்படுத்தலாம். ஆனால் சாத்தியமான எல்லா காட்சிகளிலும், ஒன்றை முன்னிலைப்படுத்துவது மதிப்பு.

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

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

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

for (statement 1; condition; statement 2)
{
   block of statements
}

ஒரு whileவளைய அடைப்புக்குறிக்குள் ஒரு நிபந்தனை உள்ளது, ஆனால் ஒரு forவளையம் அரைப்புள்ளிகளால் பிரிக்கப்பட்ட இரண்டு அறிக்கைகளைச் சேர்க்கிறது.

யதார்த்தம் ஒலிப்பதை விட எளிமையானது: கம்பைலர் ஒரு forசுழற்சியை whileஇது போன்ற ஒரு சாதாரண சுழற்சியாக மாற்றுகிறது:

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

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

for (int i = 0; i < 20; i++)
{
   System.out.println(i);
}

int i = 0;
while (i < 20)
{
   System.out.println(i);
   i++;
}

கவுண்டர் மாறி தொடர்பான அனைத்து குறியீடுகளையும் ஒரே இடத்தில் சேகரித்தோம் i.

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

ஸ்டேட்மெண்ட் 2 ஆனது லூப்பின் உடலமைப்பின் அதே எண்ணிக்கையில் செயல்படுத்தப்படுகிறது, மேலும் ஒவ்வொரு முறையும் லூப்பின் முழு உடலும் செயல்படுத்தப்பட்ட பிறகு அது செயல்படுத்தப்படுகிறது.

2. forலூப் எங்கே பயன்படுத்தப்படுகிறது

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

எடுத்துக்காட்டுகள்:

int i = 3;
while (i >= 0)
{
   System.out.println(i);
   i--;
}

for (int i = 3; i >= 0; i--)
{
   System.out.println(i);
}

int i = 0;
while (i < 3)
{
   System.out.println(i);
   i++;
}

for (int i = 0; i < 3; i++)
{
   System.out.println(i);
}

boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

for (boolean isExit = false; !isExit; )
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

while (true)
   System.out.println("C");

for (; true; )
   System.out.println("C");

while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
      break;
}

for (; true; )
{
   String s = console.nextLine();
   if (s.equals("exit"))
      break;
}

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

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

for3. லூப்பைப் பயன்படுத்துவதற்கான நுணுக்கங்கள்

forலூப்கள் breakமற்றும் continueஸ்டேட்மென்ட்களைப் பயன்படுத்துவது பற்றிய ஒரு முக்கியமான விஷயம் .

ஒரு லூப்பில் breakஉள்ள அறிக்கை forஒரு லூப்பில் உள்ளதைப் போலவே செயல்படுகிறது while- அது உடனடியாக வளையத்தை நிறுத்துகிறது. ஒரு continueஅறிக்கை லூப் உடலைத் தவிர்க்கிறது, ஆனால் இல்லை statement 2(இது லூப் கவுண்டரை மாற்றுகிறது).

forஎப்படி மற்றும் whileசுழல்கள் தொடர்புடையது என்பதை இன்னொரு முறை பார்க்கலாம் .

for (statement 1; condition; statement 2)
{
   block of statements
}

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

ஒரு ஸ்டேட்மெண்ட் ஒரு continueforலூப்பில் செயல்படுத்தப்பட்டால் , மீதமுள்ள ஸ்டேட்மென்ட்கள் தவிர்க்கப்படும், ஆனால் ஸ்டேட்மெண்ட் 2 (லூப்பின் எதிர் மாறியுடன் செயல்படும் ஒன்று for) இன்னும் செயல்படுத்தப்படும்.

7 ஆல் வகுபடக்கூடிய ஸ்கிப்பிங் எண்களுடன் நமது உதாரணத்திற்கு வருவோம்.

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
   i++;
}

for (int i = 1; i <= 20; i++)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
}

லூப்பைப் பயன்படுத்தும் குறியீடு whileவேலை செய்யாது - நான் 7 ஐ விட அதிகமாக இருக்க மாட்டேன். ஆனால் லூப் உள்ள குறியீடு forநன்றாக வேலை செய்யும்.

4. லூப்களுக்கான ஒப்பீடு: ஜாவா vs பாஸ்கல்

மூலம், பாஸ்கலுக்கும் ஒரு Forவளையம் உள்ளது. பொதுவாக, அடிப்படையில் ஒவ்வொரு நிரலாக்க மொழிக்கும் ஒன்று உள்ளது. ஆனால் பாஸ்கலில் இது மிகவும் தெளிவாக உள்ளது. எடுத்துக்காட்டுகள்:

For i := 1 to 10 do
Begin
   Writeln(i);
End;

for (int i = 1; i <= 10; i++)
{
   System.out.println(i);
}

For i := 1 to 10 do step 2
Begin
   Writeln(i);
End;

for (int i = 1; i <= 10; i = i + 2)
{
   System.out.println(i);
}

For i := 10 downto 0 do step 2
Begin
   Writeln(i);
End;

for (int i = 10; i >= 0; i = i - 2)
{
   System.out.println(i);
}