Loops (பார்வை - 08)

அனைவருக்கும் வணக்கங்கள்...

இந்தப்பதிப்பின் ஊடாக சுலபமான வழிகளின் ஊடாக அதிக தடவைகள் சில தகவல்களை எவ்வாறு Print பண்ணலாம் என நோக்குவோம்.

குறிப்பாக

Print "Hello" என்ற குறியீடு பிரதான திரையில் ஒரு முறை “Hello" எனும் வாசகத்தை அச்சிடுகிறது. மேற்படி “Hello” எனும் வாசகம் பிரதான திரையில் 10 தடவைகள் அச்சிடப்பட வேண்டும் எனில் Print "Hello" எனும் குறியீட்டினை ஒன்றன் கீழ் ஒன்றாக 10 தடவைகள் தட்டச்சு செய்து பெற முடியும்.

 

இவ்வாறு ஒரே வகையில் கையாளக்கூடிய தகவல்களை மீண்டும் மீண்டும் குறியீடுகளை தட்டச்சு செய்வதன் மூலம் பெறுவதை விடுத்து சில அடிப்படை கணித அறிவினை இங்கு புகுத்துவதன் மூலம் இவ்வாறான செயல்களை இலகுவாக செய்திடலாம். அதாவது மீண்டும் மீண்டும் ஒரே வகையான செயலினை செய்வதை தான் Loop என்கிறோம். 

மேற்படி “Hello” வாசகத்தினை பத்து தடவைகள் Print "Hello" என்று தட்டச்சு செய்யாமல் வேறு எந்த வழியில் இலகுவாக பிரதான திரையில் பதியச்செய்யலாம் என்று நோக்குவோம். 

  

மீண்டும் மீண்டும் Print "Hello" என்று தட்டச்சு செய்யாமல் இங்கு 5 வரிகளுக்குள்ளாகவே பத்து தடவைகள் " Hello" என்று தட்டச்சு செய்யப்படுகிறது. பத்து தடவைகளுக்கு மட்டுமல்ல 1000 தடவைகள் என்றாலும் மேற்படி 5 வரிகளுக்குள்ளாகவே அதற்குரிய கட்டளைகள் இடப்படுகின்றன.

இங்கு எழுதப்பட்டிருக்கின்ற கட்டளைகள் மூலம் நிறைவேற்றப்படுவது தான் Loop எனும் செயன்முறை. அதாவது குறிப்பிட்ட சில கட்டளைகள் மீண்டும் மீண்டும் இயங்குவதன் ஊடாகவே எம்மால் 10 தடவைகள் Hello எனும் வாசகத்தை பெறமுடிந்துள்ளது. குறியீட்டு பகுதியில் Print “Hello” என்று ஒரு தடவை மாத்திரம் எழுதப்பட்டும் பிரதான திரையில் மேற்படி வாசகம் 10 தடவைகள் இடம் பெறுகின்றதென்றால் மேற்படி குறியீடு (Print "Hello")பத்து தடவைகள் இயங்கியுள்ளது என்று தானே அர்த்தம். 

பார்க்கலாம். Loop பற்றிய ஒரு பார்வையை மேலுள்ள பகுதி மூலம் பார்த்துவிட்டோம். இனி, Loop பற்றியதான விளக்கங்களின் ஊடாக மேலும் சில விடயங்களை நோக்கலாம். 

பொதுவாக Visual Basic இல் Loops இனை பொதுவாக 3 வழிகளில் கையாளலாம். கையாளும் வழிமுறைகள் பற்றி பார்க்கலாம். 

1. Do... While

2. Do ... Until

3. For...

1. Do... While

இந்த வகையான Loop இனை இருவழிகளில் கையாளலாம்.

அவற்றினை குறியீகளை பயன்படுத்துவதன் மூலம் வாய்ப்பு பார்க்கலாம். 

மேலே உதாரணத்தில் காட்டப்பட்ட குறியீட்டுத்தொகுதி மூலம் இது தான் கையாளப்பட்டுள்ளது. 

1 என இலக்கமிடப்பட்டுள்ள குறியீடு இடப்பட்டதன் நோக்கம் என்னவென்பதை தாங்கள் முன்னைய பதிவுகளின் மூலம் அறியக்கூடயதாக இருக்கும் என எண்ணுகிறேன். x எனும் integer Variable இனை Declare பண்ணும் குறியீடு தான் அது.

குறிப்பிட்ட Variable (x) Declare பண்ணுப்பட்டவுடன் அதன் பெறுமதி 0 ஆக கருதப்படுகிறது. 

அதன் பின்னர் எழுதப்படும் 4 வரிகளுமே குறிப்பிட்ட Loop இனை கையாளும் குறியீடுகளாக (Codes) அமைகின்றன. அதிலும் "Do" என்று குறிப்பிடும் பட்சத்தில் அவற்றிற்கு கீழே உள்ளவற்றை செயல்படுத்து எனும் கட்டளை அங்கே பிறப்பிக்கப்படுகிறது. 

இங்கு “Do” என்று குறிப்பிட்டு அதனுடனேயே குறிப்பிட்ட செயற்முறைக்கான வரையறையையும் செய்து கொள்ளுகிறோம். (Condition). மஞ்சள் நிறத்தால் மூடப்பட்டிருக்கும் குறியீட்டுப்பகுதி (While x<10) இனால் மேற்படி Loop எந்த கட்டம் வரைக்கும் இயங்கவேண்டும் எனும் வரையறை வழங்கப்படுகிறது. அதாவது x இன் பெறுமானம் 10இற்கு குறைவானதாக இருக்கும் சந்தர்ப்பத்தில் Loop இனை செயற்படுத்து என்று பொருள்படுகிறது. 

ஏற்கனவே செயற்படுத்தக்கூடிய குறியீடுகள் "Do" எனும் குறியீட்டிற்கு கீழ் உள்ள பகுதிகளை என்று கூறிவிட்டேன்...

ஆகவே இலக்கம் 2 ஆல் குறிப்பிடப்பட்ட ( Print "Hello", x=x+1) போன்ற குறியீடுகள் செயற்படுத்தப்படுகின்றன. 

காரணம் "Loop" எனும் குறியீட்டினை Loop இயக்கமானது முடிவடைவதை குறிப்பிடுவதற்காக தான் அங்கு பதிவு செய்கிறோம். ஆகையால் “Do” எனும் பகுதிக்கு கீழே உள்ளதும் “Loop” எனும் பகுதிக்கு மேலே உள்ளதுமான குறியீடுகளை  குறிப்பிட்ட வரையறைகளிற்கு(Condition,x<10) அமைவாக இயக்கு என்பதை பொருள்படக்கூடியவாறே மேற்படி குறியீட்டுத்தொகுதி (Code set) அமைக்கப்பட்டுள்ளது. 

 இப்போது மீண்டும் மீண்டும் செயற்படுத்தப்படுகின்ற அந்த இரு குறியீடுகள் மூலம்  ( Print "Hello", x=x+1 ) என்ன குறிப்பிடப்பட்டுள்ளது என்று நோக்குவோம். 

Print "Hello"

 "Hello" எனும் வாசகத்தை பிரதான திரையில் பதிவு செய்.

x=x+1

x+1 இன் பெறுமதி எதுவோ அதை x இற்கு வழங்கு...

அதாவது Variable x இனை Declare பண்ணியவுடன் அதன் பெறுமதி 0 என குறிப்பிட்டிருந்தேன். ஆகவே x+1 (0+1) இன் பெறுமதியான 1 இனை x இன் பெறுமதியாக்கு என்று பொருள்படுகிறது. 

மேலே காட்டப்பட்ட படம் மூலமாக குறியீடுகள் கையாளப்படும் படிமுறைகளும் குறித்த படிமுறையில் x இன் பெறுமதியும் காட்டப்பட்டுள்ளது. 

அங்கு 2ம் படிமுறையின் பின்னர் 3,4ம் படிமுறைகள் செயல்படுத்தப்படும். செயற்படுத்தப்பட்ட பின்னர் குறியீட்டு வரைமுறை (Condition, x<10) ஆராயப்பட்டு (படிமுறை 5) சரியாகும் பட்சத்தில் மீண்டும் Print "Hello" மற்றும் x=x+1 எனும் குறியீடுகள் செயல்படுத்தப்படுகின்றன. Condition பிழையாகும் வரை மேற்படி இரு குறீயீடுகளும் மீண்டும் மீண்டும் செயல்படுத்தப்படுவதை மேலே காட்டப்பட்ட படம் விளங்கப்படுத்துகிறது. 

இங்கு Condition இல் 10 இற்கு குறைவாக என்று கட்டளை இட்டதன் காரணமாக “Hello”  எனும் வாசகம் 10 தடவைகள் மாத்திரம் பதிவு செய்யப்பகிறது. 

அங்கே x<1000 என கொடுக்கப்படும் பட்சத்தில் ஒன்றன் பின் ஒன்றாக “Hello” எனும் வாசகம் 1000 தடவைகள் பதிவு செய்யப்படும்.

Loop பற்றிய தெளிவான ஆழமான விளக்கத்தினை என்னால் இயன்ற அளவு விளக்கியிருக்கிறேன் என எண்ணுகிறேன். 

அடுத்த பதிவுகளின் ஊடாக Loop கையாளப்படும் ஏனைய வழிமுறைகளை பார்க்கலாம். 

பார்வைகள் தொடரும் ...