உதாரணம் மூலம் மொழி எழில் கற்கவும் (Learn Ezhil Language by Example)

உதாரணம் மூலம்  மொழி எழில் கற்கவும் (Learn Ezhil Language by Example)
Author: Naga Chokkanathan (என். சொக்கன்)
உங்களுக்கு உதவும் உதாரணங்கள்
எழில் மொழியைக் கற்பதில் உங்களுக்கு உதவுவதற்காகவே, நாங்கள் பல உதாரண நிரல்களை உருவாக்கியிருக்கிறோம். இவற்றை முறைப்படி பார்வையிட்டாலே போதும், நீங்களே சொந்தமாக “எழில்” நிரல்கள் எழுதத் தொடங்கிவிடலாம்.
ஆனால், எந்த வரிசையில் பார்ப்பது? எங்கே பார்ப்பது?
அதற்கு வழிகாட்டதான் இந்தக் கட்டுரை. “எழில்” மொழியின் அடிப்படைக் கூறுகளில் தொடங்கி, ஒவ்வோர் அம்சத்தையும் உதாரண நிரல்களின் வழியே கற்பது எப்படி என்று இங்கே பார்ப்போம்.
இந்தக் கட்டுரையில் தரப்பட்டுள்ள வரிகள்மட்டும்தான் என்றில்லை, இதுபோல் இன்னும் பல வரிகள் உதாரண நிரல்களில் உண்டு. அவற்றைத் தேடிப் படிக்கப் படிக்கவும், புரிந்துகொள்ளவும் உங்களுக்கு “எழில்”பற்றி நன்கு விளங்கும். புதிய நிரல்கள் எழுதுவதற்கான நம்பிக்கை, வழிமுறைகள் கிடைக்கும்.
1. அச்சிடுதல்
இதில் இரண்டு வகை உண்டு: எழுத்துச் சரங்களை அச்சிடுதல், நிரலில் உள்ள விவரங்களை அச்சிடுதல்.
1அ. எழுத்துச் சரங்களை அச்சிடுதல்:
உதாரண நிரல்: quiz.n
இதில் முதலாவதாக உள்ள வரியைக் கவனியுங்கள்:
பதிப்பி “இந்தியாவின் தலைநகரம் எது?”
இந்த வாசகம், “இந்தியாவின் தலைநகரம் எது?” என்கிற எழுத்துச் சரத்தைத் திரையில் அச்சிடுகிறது. இதுபோல் நீங்கள் விரும்பும் எந்த எழுத்துச் சரத்தையும் திரையில் அச்சிடலாம்.
1ஆ. நிரலில் உள்ள விவரங்களை அச்சிடுதல்
உதாரண நிரல்: string_demo.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
பதிப்பி “முதல் சொல்லின் நீளம் “, நீளம்(அ)
நாம் ஏற்கெனவே பார்த்த “பதிப்பி” வரிக்கும் இதற்கும் உள்ள வித்தியாசம் புரிகிறதல்லவா? இங்கே வழக்கமான எழுத்துச் சரத்துடன், அந்த நிரலில் உள்ள “அ” என்ற மாறியின் நீளத்தைக் கணக்கிட்டு அதையும் சேர்த்துத் திரையில் அச்சிடுகிறோம். உதாரணமாக: “முதல் சொல்லின் நீளம் 10” என்பதுபோல்.
இதேமாதிரி நாம் எத்தனை விவரங்களை வேண்டுமானாலும் “பதிப்பி” வாக்கியத்தில் சேர்க்கலாம்.
உதாரண நிரல்: calendar_days.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
பதிப்பி month+1,”]“,எடு(months,month), “ has “,எடு(days,month),” days
இங்கே ஒரே வரியில் பல விவரங்கள் சேர்த்து அச்சிடப்பட்டுள்ளதைப் பாருங்கள். இதுபோல் நீங்கள் உங்கள் நிரல்களின் விடைகளை வாசகர்களுக்குச் சொல்ல “பதிப்பி”யைப் பயன்படுத்தலாம்.
2. உள்ளிடுதல்
சில நேரங்களில், “எழில்” நிரல் இயங்குவதற்குப் பயனாளர் (User) ஒன்று அல்லது அதற்கு மேற்பட்ட எண்களையோ எழுத்துகளையோ உள்ளிடவேண்டும் (Input). உதாரணமாக, கூட்டல் நிரல் இயங்க நாம் இரண்டு எண்களைத் தரவேண்டுமல்லவா?
இதற்கு நாம் “உள்ளீடு” என்ற கட்டளையைப் பயன்படுத்துகிறோம்.
உதாரண நிரல்: leapyear.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
வருடம் = int(உள்ளீடு(“வருடத்தின் எண்ணை உள்ளீடு செய்க (உ.தா) 1984;“))
இங்கே ”உள்ளீடு” என்ற கட்டளை வந்துள்ளதால், “எழில்” நீங்கள் தந்துள்ள சரத்தைத் திரையில் அச்சிட்டுவிட்டுக் காத்து நிற்கும், பதிலுக்குப் பயனாளர் ஓர் எண்ணை உள்ளிடவேண்டும், அந்த எண் “வருடம்” என்ற மாறியில் சேமிக்கப்படும். பின்னர், அதை வைத்து அடுத்தடுத்த கணக்குகள் நிகழ்வதை மேற்சொன்ன உதாரண நிரலில் சென்று விரிவாகக் காணுங்கள்.
சுருக்கமாகச் சொன்னால், “உள்ளீடு” என்பது விவரங்களைப் பயனாளரிடமிருந்து பெறுதல், “பதிப்பி” என்பது விவரங்களைப் பயனாளருக்கு வழங்குதல். இந்த இரண்டையும் சேர்த்துப் பயன்படுத்தினால் நீங்கள் பயனாளருடன் கலந்து உரையாடும்விதமான (Interactive) நிரல்களை எழுதமுடியும்.
3. ஒப்பிடுதல்
இரண்டு எண்கள் அல்லது எழுத்துகளை “எழில்” நிரல்களில் எப்படி ஒப்பிடுவது?
உதாரண நிரல்: ackermann.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@(முதலெண் == 0) ஆனால்
இந்த வாசகம், “முதலெண்” என்ற மாறியின் மதிப்பு பூஜ்ஜியமா என்பதைப் பார்க்கிறது, அதன் அடிப்படையில் வேறு சில நிரல் வாசகங்களை நிறைவேற்றுகிறது. இதற்கு நாம் “==” என்ற குறியீட்டைப் பயன்படுத்துகிறோம்.
உதாரண நிரல்: histogram.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@(முந்தினசொல் != “”) ஆனால்
இந்த வாசகத்தை முந்தைய வாசகத்துடன் ஒப்பிட்டுப் பாருங்கள். “முந்தினசொல்” என்ற மாறியில் உள்ள மதிப்பு “”ஆக இல்லையா என்பதை இந்த வாசகம் பார்க்கிறது. அதன் அடிப்படையில் வேறு சில நிரல் வாசகங்களை நிறைவேற்றுகிறது. இதற்கு நாம் “!=” என்ற குறியீட்டைப் பயன்படுத்துகிறோம்.
4. மேலும் சில ஒப்பீடுகள்
==, != ஆகியவைதவிர, இன்னும் பல ஒப்பீட்டுக் குறியீடுகளும் “எழில்” மொழியில் உண்டு. அவை:
* சிறியது “<”
* பெரியது “>”
* சிறியது அல்லது சமம் “<=”
* பெரியது அல்லது சமம் “>=”
உதாரண நிரல்: rich_poor.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@( வருமானம் > 10000 ) ஆனால்
இந்த வாசகம் “வருமானம்” என்ற மாறியில் உள்ள எண் பத்தாயிரத்தைவிட அதிகமா என்று பார்க்கிறது. அதன் அடிப்படையில் வேறு சில நிரல் வாசகங்களை நிறைவேற்றுகிறது. இதேபோல் நாம் “<“, “<=”, “>=” ஆகிய குறியீடுகளையும் பயன்படுத்தலாம். அவற்றுக்கான பல உதாரணங்கள் இங்கே உள்ளன.
5. ஒன்றுக்கு மேற்பட்ட ஒப்பீடுகள்
இதுவரை நாம் பார்த்த உதாரணங்கள் அனைத்திலும், ஒரு வாசகத்தில் ஒரே ஒரு விஷயத்தைமட்டும்தான் (சமம், சமமல்ல, சிறியது, பெரியது) ஒப்பிட்டுள்ளோம். ஒருவேளை நாம் ஒன்றுக்கு மேற்பட்ட விஷயங்களை ஒப்பிடவேண்டியிருந்தால் என்ன செய்வது?
இதற்கு “எழில்” வழங்கும் குறியீடுகள் இவை:
  • && (AND / மற்றும்)
  • || (OR / அல்லது)
இவற்றில் “&&” குறியீட்டைப் பயன்படுத்தினால், அதற்கு முன்னால், பின்னால் இருக்கும் இரண்டு ஒப்பீடுகளும் உண்மையாகவேண்டும். “||” குறியீட்டைப் பயன்படுத்தினால், இவற்றில் ஏதேனும் ஒன்று உண்மையானாலே போதுமானது.
உதாரண நிரல்: ackermann.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@((முதலெண் > 0) && (இரண்டாமெண் == 00)) ஆனால்
இந்த வாசகத்தில் இரண்டு ஒப்பீடுகள் உள்ளன: முதலெண் பூஜ்ஜியத்தைவிடப் பெரியது, இரண்டாமெண் பூஜ்ஜியத்துக்குச் சமம். இந்த இரண்டுக்கும் இடையே “&&” உள்ளது.
இதன் பொருள், முதலெண் பூஜ்ஜியத்தைவிடப் பெரியதாக இருந்து, இரண்டாமெண் பூஜ்ஜியத்துக்குச் சமமாக இருந்தால்தான் கீழே தரப்பட்டுள்ள கட்டளைகள் நிறைவேறும்.
உதாரண நிரல்: interest.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@(மூலதனம் == 0 || வட்டி_வீதம் == 0 || வருடம் ==0 ) ஆனால்
இங்கே மூன்று ஒப்பீடுகள் உள்ளன: மூலதனம் பூஜ்ஜியம், வட்டி_வீதம் பூஜ்ஜியம், வருடம் பூஜ்ஜியம். இவற்றின் இடையே “||” உள்ளது.
இதன் பொருள், மூலதனம் பூஜ்ஜியமாக இருக்கவேண்டும், அல்லது வட்டி_வீதம் பூஜ்ஜியமாக இருக்கவேண்டும், அல்லது வருடம் பூஜ்ஜியமாக இருக்கவேண்டும். இந்த மூன்றில் ஏதாவது ஒன்று சரியாக இருந்தாலும் கீழே தரப்பட்டுள்ள கட்டளைகள் நிறைவேறும்.
ஒன்றுக்கு மேற்பட்ட ஒப்பீடுகளைச் செய்யும்போது, அடைப்புக்குறிகளைச் சரியானமுறையில் பயன்படுத்தவேண்டும். இல்லாவிட்டால் சரியான பலன்கள் கிடைக்காது.
உதாரண நிரல்: leapyear.n
இதில் பின்வரும் வரியைக் கவனியுங்கள்:
@( ( ((வருடம் % 4) == 0) &&((வருடம் % 100)!= 0) )||((வருடம் % 400) ==0) ) ஆனால்
இங்கே மூன்று ஒப்பீடுகள் உள்ளன. அவற்றை && மற்றும் || ஆகிய குறியீடுகளைப் பயன்படுத்தி, அடைப்புக்குறிகளின் உதவியுடன் இணைத்துள்ளோம். இப்படி:
(”முதல் ஒப்பீடு” மற்றும் “இரண்டாம் ஒப்பீடு”) அல்லது “மூன்றாம் ஒப்பீடு”
இதன் பொருள், முதல் ஒப்பீடு, இரண்டாம் ஒப்பீடு இரண்டும் சரியாக இருக்கவேண்டும், அல்லது, மூன்றாம் ஒப்பீடுமட்டும் சரியாக இருக்கவேண்டும். அப்போது கீழே தரப்பட்டுள்ள கட்டளைகள் நிறைவேறும்.
இதுபோல், ஒப்பீடுகளை நம் தேவைக்கேற்பப் பலவிதங்களில் இணைத்துப் பயன்படுத்த இயலும்.
6. இதுவா? அல்லது, அதுவா?
சில நேரங்களில், ஒரு குறிப்பிட்ட ஒப்பீடு உண்மை என்றால், நாம் சில கட்டளைகளை இயக்குவோம், ஒருவேளை அது உண்மை அல்ல என்றால், வேறு சில கட்டளைகளை இயக்குவோம். ஆங்கிலத்தில் இதனை If-Else Construct என்று அழைப்பார்கள்.
“எழில்” நிரலில் இதனை எப்படிச் செய்வது?
உதாரண நிரல்: lcmgcd.n
இதில் பின்வரும் வரிகளைக் கவனியுங்கள்:
@(எண்1 == எண்2) ஆனால்
<கட்டளை 1>
@(எண்1 > எண்2) இல்லைஆனால்
<கட்டளை 2>
இல்லை
<கட்டளை 3>
முடி
இங்கே நாம் முதலில் எண்1, எண்2 இரண்டும் சமமா என்று பார்க்கிறோம், ஆம் எனில் ஒரு கட்டளையை நிறைவேற்றுகிறோம். ஒருவேளை அவை சமமாக இல்லாவிட்டால், எண்1 பெரியதா என்று பார்க்கிறோம், ஆம் எனில் இன்னொரு கட்டளையை நிறைவேற்றுகிறோம், அதுவும் இயலாவிட்டால் வேறொரு கட்டளையை நிறைவேற்றுகிறோம்.
இப்படி நாம் எத்துணை ஒப்பீடுகளை வேண்டுமானாலும் பிணைக்கலாம், அதற்கு ஓர் “ஆனால்” (IF), பல “இல்லைஆனால்”கள் (ElseIF), ஓர் “இல்லை” (Else) தேவைப்படும்.
7. ஒரே பணியைத் திரும்பத் திரும்பச் செய்தல்
கணினியின் மிகப் பெரிய பலம், ஒரே பணியைத் திரும்பத் திரும்பப் பலமுறை விரைவாகச் செய்வதுதான். “எழில்” மொழியிலும் நீங்கள் அதனைச் சிறப்பாகச் செய்யலாம்.
இதில் இரண்டு வகைகள் உண்டு:
* வரை: ஒப்பீட்டைப் பரிசோதித்துவிட்டுக் கட்டளைகளை நிறைவேற்றுவது (While)
* முடியேனில்: கட்டளைகளை நிறைவேற்றிவிட்டு ஒப்பிடுவது (Until)
உதாரண நிரல்: tables.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
அ = 1
@( அ <= 10 ) வரை
<கட்டளைகள்>
அ = அ + 1
முடி
இங்கே ”அ” என்ற மாறியின் மதிப்பு 1ஆக உள்ளது. பின் அது படிப்படியாக அதிகரிக்கிறது, அது பத்து என்ற எண்ணைத் தாண்டும்வரை, சில கட்டளைகள் நிறைவேற்றப்படுகின்றன. “அ > 10” என்ற நிலை ஏற்பட்டதும் (அதாவது, “அ <= 10” என்ற ஒப்பீடு தவறானதும்), அந்தக் கட்டளைகள் நிறைவேற்றப்படுவது நின்றுவிடுகிறது.
”முடியேனில்” வாசகமும் கிட்டத்தட்ட இதேமாதிரிதான். ஆனால் கட்டளைகளை நிறைவேற்றியபிறகுதான் மாறியில் உள்ள மதிப்பு பரிசோதிக்கப்படும்.
உதாரண நிரல்: dowhile.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
அ = 0
செய்
<கட்டளைகள்>
அ = அ + 1
முடியேனில் @(அ < 5)
முந்தைய நிரல் வரிகளோடு இதை ஒப்பிட்டுப் பாருங்கள், இரண்டும் கிட்டத்தட்ட ஒரேமாதிரி தோன்றினாலும், ஒரு முக்கியமான வித்தியாசம் உள்ளது.
அங்கேபோலவே இங்கேயும் “அ < 5” என்ற ஒப்பீடு இருக்கிறது, “அ” என்ற மாறியின் மதிப்பு ஒவ்வொன்றாக அதிகரிக்கிறது. ஆனால், அந்த ஒப்பீடு, கட்டளைகள் அனைத்தையும் நிறைவேற்றியபிறகுதான் நிகழ்த்தப்படுகிறது. இதுதான் இந்த இரு வாசகங்களுக்கும் இடையே முக்கியமான வேறுபாடு.
உங்களது நிரல்களில் “வரை” அல்லது “முடியேனில்” வாசகங்களைச் சரியானமுறையில் பயன்படுத்தினால் மிகப் பெரிய மதிப்புகளைக்கூடப் படிப்படியாக அலசி விடை காணமுடியும்.
8. ஒவ்வொன்றாக அலசுதல்
சில நேரங்களில் தொகுப்பான விவரங்களை ஒவ்வொன்றாக எடுத்து அலச வேண்டியுள்ளது. அப்போது உங்களுக்குப் பயன்படும் இரண்டு கட்டளைச் சொற்கள் “எழில்” மொழியில் உண்டு. அவை:
  •  ஒவ்வொன்றாக (For Each)
  •  ஆக (For)
உதாரண நிரல்: stringreverse.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
@( சரம்1 இல் இ) ஒவ்வொன்றாக
சரம்2 = இ + சரம்2
முடி
இங்கே “சரம்1” என்பது ஓர் எழுத்துச் சரம். அதில் ஒவ்வோர் எழுத்தாக எடுத்து, “சரம்2” என்ற எழுத்துச் சரத்தில் மாற்றிச் சேமிக்கிறோம். அதற்கு “ஒவ்வொன்றாக” என்ற கட்டளை பயன்படுகிறது.
உதாரண நிரல்: loopupdate.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
@(எண் = 1, எண் <= 100, எண் = எண் + 1) ஆக
     பதிப்பி எண்
முடி
இங்கே நாம் “எண்” என்ற மாறியில் 1ல் தொடங்கி ஒவ்வொன்றாக அதிகரித்து 100வரை எண்களைச் சேமிக்கிறோம், அதைத் திரையில் பதிப்பிக்கிறோம்.
இதுபோல் எண்கள், எழுத்துகள் அடிப்படையிலான பல அலசல் பணிகளை இந்த இரு கட்டளைச் சொற்களைப் பயன்படுத்திச் சிறப்பாக எழுதலாம்.
குறிப்பாக, பட்டியல், dict என்ற இரு வகை விவரங்களை அலசுவதற்கு இது மிகவும் உபயோகப்படும். அதனைப் பின்னர் விரிவாகக் காண்போம்.
9. தேர்ந்தெடுத்தல்
ஒரே மாறியில் பல மதிப்புகள் இருக்கக்கூடும் என்ற சூழ்நிலையில், அவை ஒவ்வொன்றுக்கும் வெவ்வேறு கட்டளைகளை நிறைவேற்றுவதற்குத் “தேர்ந்தெடு” என்ற கட்டளைச் சொல் பயன்படும்.
உதாரண நிரல்: select_case.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
@(ஊர்) தேர்ந்தெடு
@(“சென்னை”) தேர்வு
<கட்டளை 1>
@(“கோவை”) தேர்வு
<கட்டளை 2>
@(“மதுரை”) தேர்வு
<கட்டளை 3>
ஏதேனில்
<கட்டளை 4>
முடி
இங்கே “ஊர்” என்ற மாறியில் உள்ள மதிப்பு சென்னையா, அல்லது கோவையா, அல்லது மதுரையா என்பதைப் பொறுத்து கட்டளை 1 அல்லது கட்டளை 2 அல்லது கட்டளை 3 நிறைவேற்றப்படும். இந்த மூன்றும் அல்லாத வேறு ஊர்களுக்குக் கட்டளை 4 நிறைவேற்றப்படும். இதைதான் “ஏதேனில்” என்ற சொல் குறிப்பிடுகிறது.
10. நிறுத்துதல் தொடர்தல்
நீங்கள் ஒரே செயலைப் பல மதிப்புகளுக்கு ஏற்ப திரும்பத் திரும்பச் செய்துகொண்டிருக்கும்போது, அவற்றை அவ்வப்போது நிறுத்தி அடுத்த மதிப்புக்குச் செல்லவேண்டியிருக்கலாம், அல்லது, அதனைச் செய்வதிலிருந்து வெளியேறவேண்டியிருக்கலாம். ஆங்கிலத்தில் இதனை Break, Continue என்பார்கள். இதற்கு இணையான “எழில்” மொழிச் சொற்கள் இவை:
  •  நிறுத்து (break)
  •  தொடர் (continue)
இதில் ‘நிறுத்து’ என்பது, நிறைவேற்றப்பட்டுக்கொண்டிருக்கும் தொடர்ச்சியான பணியை நிறுத்தி வெளியேறுதல், அதாவது, மீதமிருக்கும் மதிப்புகளையோ கட்டளைகளையோ நிறைவேற்றவேண்டியதில்லை.
உதாரண நிரல்: prime.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
@( p >= 2 ) வரை
      @( fmod( n, p ) == 0 ) ஆனால்
              நிறுத்து
      முடி
      p = p – 1
முடி
இங்கே நாம் ஒரு “வரை” வளையத்தினுள் இருக்கிறோம். ஆனால் ஒரு குறிப்பிட்ட நிபந்தனை நிறைவேறும்போது, அடுத்தடுத்த எண்களைப் பரிசோதிக்காமல் வெளியேறிவிடுகிறோம், அதற்கு “நிறுத்து” என்ற கட்டளைச் சொல் பயன்படுகிறது.
அதாவது, ஒரு வளையம் 1, 2, 3 என்று 100வரை செல்வதாக வைத்துக்கொள்வோம். அதை நீங்கள் ஏதோ காரணத்துக்காக 35ல் நிறுத்த நேரலாம். அப்போது “நிறுத்து” என்ற சொல்லைப் பயன்படுத்தினால் 36, 37 முதலான எண்கள் பயன்படுத்தப்படாது.
உங்களது நிரல்களில் எப்போதெல்லாம் ஒரு வளையம் (Loop) இதற்குமேல் செயல்படவேண்டியதில்லை என்கிற சூழ்நிலை வருகிறதோ, அப்போதெல்லாம் இந்தக் கட்டளைச் சொல்லைப் பயன்படுத்துங்கள். இதன்மூலம் விடையும் சரியாகக் கிடைக்கும். கணினியின் செயல்திறனும் வீணாகாமல் காக்கப்படும்.
அடுத்து, “தொடர்” என்ற கட்டளைச் சொல். இது “நிறுத்து”க்கு நேர் எதிரானது. இங்கே நீங்கள் வளையத்தைத் தொடர்ந்து செயல்படுத்த விரும்புகிறீர்கள். ஆனால் இந்தக் குறிப்பிட்ட மதிப்புக்கு மீதமிருக்கும் கட்டளைகளைப் பயன்படுத்த விரும்பவில்லை.
அதாவது, வளையம் 1, 2, 3 என்று தொடர்ந்து 100வரை செல்கிறது. அதே 35ல் “நிறுத்து”க்குப் பதில் “தொடர்” என்ற வாசகத்தைப் பயன்படுத்துகிறோம். அப்போது, 35 என்ற மதிப்புக்கு மீதமுள்ள கட்டளைகள் நிறைவேற்றப்படாது. ஆனால் 36முதல் உள்ள கட்டளைகள் எப்போதும்போல் நிறைவேற்றப்படும்.
உதாரண நிரல்: nqueens.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
@( i = 0, i < n, i = i + 1 ) ஆக
<சில கட்டளைகள்>
@( j < col ) ஆனால்
      தொடர்
முடி
<மேலும் சில கட்டளைகள்>
முடி
இங்கே “சில கட்டளைகள்” முதலில் நிறைவேற்றப்படும், அதன்பிறகு ஓர் ஒப்பீடு (“j < col”) செய்யப்படும். ஒருவேளை அது நிஜம் எனில், மீதமுள்ள “மேலும் சில கட்டளைகள்” இந்த மதிப்புக்கு நிறைவேற்றப்படாது, “ஆக” வளையம் அடுத்த மதிப்புக்குச் சென்றுவிடும்.
”நிறுத்து” மற்றும் “தொடர்” இடையிலான வித்தியாசம் நுட்பமானது. அதை அறிந்து சரியாகப் பயன்படுத்தினால் உங்கள் நிரல் மிகத் துல்லியமாக இயங்கும்.
11. அதிக விவரங்கள்
“எழில்” மொழியில் அதிக விவரங்களைத் தொகுத்துவைக்க இரண்டு வழிகள் உண்டு:
  •  பட்டியல்
  •  Dict
இதில் பட்டியல் 1D எனப்படும் ஒற்றைப் பரிமாண வகையைச் சேர்ந்தது. அதாவது, ஒன்றன்கீழ் ஒன்றாகப் பல விவரங்களைத் தொகுத்துவைக்கலாம். உதாரணமாக, மாணவர்களின் பெயர்கள்.
அதே பட்டியலில், ஒவ்வொரு மாணவர் பெயருக்கும் அருகே அவர் வாங்கிய மதிப்பெண்களைச் சேர்க்க விரும்பினால், அதற்கு Dict பயன்படும். இது 2D, இரட்டைப் பரிமாண வகையைச் சேர்ந்தது.
பட்டியல், Dict இரண்டிலும் நாம் விவரங்களைத் தொகுக்கலாம், எடுக்கலாம். அதற்கான வழிவகைகள் அனைத்தும் தரப்பட்டுள்ளன.
உதாரண நிரல்: string_demo.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
ப = பட்டியல்()
பின்இணை( ப , “வாழை”)
பின்இணை( ப , “கொய்யா” )
பின்இணை( ப , “மா”)
 
பதிப்பி எடு(ப,0), எடு(ப ,1)
 
தலைகீழ்( ப )
 
வரிசைப்படுத்து( ப )
 
பதிப்பி “பட்டியல் நீளம்”, நீளம்( ப )
 
நீட்டிக்க( ப , ப )
இந்த வரிகளில் நாம் பட்டியலை உருவாக்குவதை அறிகிறோம், அதில் விவரங்களைச் சேர்க்கத் தெரிந்துகொள்கிறோம், அவற்றை எடுத்துத் திரையில் அச்சிடப் பழகுகிறோம், தலைகீழாக்குகிறோம், வரிசைப்படுத்துகிறோம், நீளம் கண்டுபிடிக்கிறோம், நீட்டிக்கிறோம்…
இப்படி உங்களுடைய நிரல்களிலும் விவரங்களைச் சேர்த்துப் பயன்படுத்தும் தேவை வரும்போதெல்லாம், பட்டியலைப் பயன்படுத்திக்கொள்ளுங்கள்.
உதாரண நிரல்: dict.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
z = dict()
வை(z,”name”,”மணி”)
வை(z,”age”,10)
வை(z,”location”,”தஞ்சாவூர்”)
 
பதிப்பி “என் பெயர் “+எடு(z,”name”)
பதிப்பி “நான் வாழும் ஊர் “+எடு(z,”location”)
பதிப்பி “எனக்கு “+str(எடு(z,”age”))+” வயதாகிறது. “
இதை முந்தின உதாரணத்துடன் ஒப்பிட்டுப் பாருங்கள், மணி என்பவருடைய வயது, இருப்பிடம் என்பதுபோன்ற பல விவரங்களை இங்கே சேமிக்கிறோம். ஆனால் “பட்டியல்” வகையில் மணி, சுரேஷ், ரமேஷ் போன்ற பெயர்களைமட்டும் சேமிக்கலாம், அல்லது 10, 12, 25 என்று வயதுகளைமட்டும் சேமிக்கலாம், இப்படித் தொகுக்க இயலாது.
”பட்டியல்” போதும் என்கிற இடங்களில் ”Dict” பயன்படுத்துவது வீண். அதேசமயம் ”Dict” தேவைப்படும் இடங்களில் அந்தப் பணியைப் ”பட்டியல்”ஆல் செய்ய முடியாது. இந்த வித்தியாசத்தை உணர்ந்து உங்கள் நிரல்களை வடிவமைப்பது நல்லது.
12. நிரல்பாகங்கள்
ஒரேமாதிரி பணியை ஒரு நிரலில் பல இடங்களில் செய்யவேண்டியிருந்தால், Function எனப்படும் கட்டமைப்பைப் பயன்படுத்துவார்கள். அதாவது, ஒருமுறை எழுதிவிட்டு அதனைப் பலமுறை அழைத்துப் பயன்படுத்துவது.
இங்கே “எழில்” மொழியிலும் Functions உண்டு. அவற்றை “நிரல்பாகம்” என்று நாம் அழைக்கிறோம்.
உதாரண நிரல்: convert2kelvin.n
இதில் இந்த வரிகளைக் கவனியுங்கள்:
நிரல்பாகம் கெல்வின்_இருந்து_மாற்று( k )
<கட்டளைகள்
முடி
 
கெல்வின்_இருந்து_மாற்று( 0 )
இங்கே நாம் ஒரு நிரல்பாகத்தை எழுதி, அதனை உரிய இடத்திலிருந்து அழைக்கிறோம். அந்தக் கட்டளைகள் கச்சிதமாக நிறைவேற்றப்படுகின்றன. திரும்பத் திரும்ப ஒரே பணியை வெவ்வேறு இடங்களில் செய்யவேண்டிய தேவை ஏற்படும்போது, நிரல்பாகம் மிகவும் பயன்படும்.
(C) 2013 Ezhil Language Foundation
(C) 2013 இது ஒரு எழில் தமிழ் நிரலாக்க மொழி உதாரணம்

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s