பாஷ் கோட்பாடு

0. குறியீட்டு

1. பெரும்பாலான மக்களுக்கு நடக்கும் விஷயங்கள்
2. ஸ்கிரிப்டின் அமைப்பு
3. திரையில் அச்சிடுக
4. பயனர் INPUT ஐப் படிக்கவும்
5. பாஷில் கணக்கீடுகள்
6. அடிப்படையில்
7. சுழல்கள்
8. செயல்பாடுகளை
9. கெட்டாப்ஸ்

1. பெரும்பாலான மக்களுக்கு நடக்கும் விஷயங்கள்

/ bin / bash அல்லது / bin / sh

எங்கள் ஸ்கிரிப்டை இயக்கும்போது இயந்திரம் செய்யும் முதல் காரியங்களில் ஒன்று, அதை எந்த ஷெல் மூலம் செய்ய வேண்டும் என்று பார்க்கிறது. பெரும்பாலான தற்போதைய லினக்ஸ் கணினிகளில் / பின் / SH ஒரு இணைப்பு / பின் / பாஷ், ஆனால் இது எப்போதுமே அப்படி இருக்காது, எடுத்துக்காட்டாக பயன்படுத்தும் விநியோகங்களில் busybox இது கொண்டு வாருங்கள் Sh பொதுவாக அவை கொண்டு வருகின்றன பாஷ், ஆனால் நீங்கள் பயன்படுத்தினால் / பின் / SH, இது பாஷுடன் இயங்காது. அதனால்தான் எப்போதும் பயன்படுத்த பரிந்துரைக்கிறேன் / பின் / பாஷ்.

யூனிகோட் Vs ASCII

உங்கள் ஸ்கிரிப்ட்களில் "¿" அல்லது "ñ" ஐ ஏன் பயன்படுத்த முடியாது என்று நீங்கள் எப்போதாவது யோசித்திருக்கிறீர்களா? அல்லது உச்சரிப்புகளைப் பயன்படுத்தலாமா? ஊடாடும் ஸ்கிரிப்ட்களில் இது மிகவும் எரிச்சலூட்டும். ஏனென்றால், பாஷின் இயல்புநிலை குறியாக்கம் ASCII, அல்லது அதே என்ன, ஆங்கில எழுத்துக்குறி தொகுப்பு. அதை மாற்ற நாம் யூனிகோடைப் பயன்படுத்த விரும்புகிறோம் என்பதை எங்கள் ஸ்கிரிப்ட்டிடம் சொல்ல வேண்டும். அதற்காக நீங்கள் கட்டளை மொழிபெயர்ப்பாளருக்குப் பிறகு ஒரு வரியைச் சேர்க்க வேண்டும்:

# - * - குறியாக்கம்: யுடிஎஃப் -8 - * -

கவனமாக இருங்கள், இந்த வரி ஸ்கிரிப்டின் தொடக்கத்தில் இருப்பது முக்கியம்.

ஸ்கிரிப்டை இயக்கக்கூடியதாக ஆக்குங்கள்

People உடன் எத்தனை பேர் ஸ்கிரிப்ட்களை இயக்குகிறார்கள் என்பது வேடிக்கையானது$ பாஷ் script.sh" அதற்கு பதிலாக "$ ./script.sh'எல்லாவற்றிற்கும் மேலாக, இதைத்தான் நாங்கள் ஒரு ஷெல் வரையறுத்துள்ளோம்.

மரணதண்டனை அனுமதிகளைச் சேர்க்க, நீங்கள் இயக்க வேண்டும்:

sudo + x script.sh

BIN = "கோப்பு" PATH = "$ BIN $ PATH"

2. ஸ்கிரிப்டின் அமைப்பு

1. தலைப்பு
2. உலகளாவிய மாறிகள் வரையறை
3. உதவி
4. செயல்பாடுகளை
5. பிரதான உடல்

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

செயல்பாடுகளைப் பயன்படுத்த, அவை எங்கள் ஸ்கிரிப்ட்டின் முக்கிய அமைப்பின் முன் வரையறுக்கப்பட வேண்டும். எங்கள் ஸ்கிரிப்ட்டின் உலகளாவிய மட்டத்தில், முக்கிய உடலிலும் செயல்பாடுகளிலும் மாறிகளைப் பயன்படுத்த விரும்பினால், தலைப்புக்குப் பிறகு, எல்லாவற்றின் தொடக்கத்திலும் அவற்றை வரையறுக்க வேண்டும்.

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

செயல்பாட்டு உதவி () {எதிரொலி "" "எங்கள் நன்கு வடிவமைக்கப்பட்ட உதவி உரை." "" வெளியேறினால் [[-z $ 1 || $ 1 == "-ம" || $ 1 == "- உதவி"]]; பின்னர் fi க்கு உதவுங்கள்

உதவி செயல்பாட்டில் "வெளியேறு" என்பதைச் சேர்த்தால், ஒவ்வொரு முறையும் நாங்கள் உதவியை இயக்கும் போது ஸ்கிரிப்டிலிருந்து வெளியேறுவோம், எடுத்துக்காட்டாக பிழை செய்திகளுக்குப் பிறகு. குறியீட்டின் சில வரிகளை நாங்கள் சேமிக்கிறோம்.

நிபந்தனை திரையில் காட்சி உதவியைக் குறிக்கிறது மற்றும் ஸ்கிரிப்ட் அளவுருக்கள் இல்லாமல் இயங்கினால் அல்லது -h / –help குறிப்பிடப்பட்டால் வெளியேறவும். நீங்கள் பார்த்தால், பெரும்பாலான லினக்ஸ் நிரல்களின் நிலையான நடத்தை இதுதான்.

3. திரையில் அச்சிடுங்கள்

பாஷில் திரையில் அச்சிடுவதற்கு 2 முக்கிய கட்டளைகள் உள்ளன: «எதிரொலி"மேலும்"வைட்டமின்«. அவை இரண்டும் வேகமானவை மற்றும் இரண்டும் பாஷின் ஒரு பகுதியாகும். ஒரு தொடக்கநிலைக்கான முக்கிய வேறுபாடு என்னவென்றால், எதிரொலி இறுதியில் ஒரு புதிய வரியைச் சேர்க்கிறது, அதே நேரத்தில் «வைட்டமின்"இல்லை.

எக்கோ மிகவும் நல்லது மற்றும் பெரும்பாலான மக்கள் பயன்படுத்துகிறார்கள், இருப்பினும் பயனரின் INPUT ஐப் படிக்கும்போது அல்லது கோப்புகளிலிருந்து எடுக்கப்பட்ட மாறிகளை சொல் செயலாக்கத்தால் அச்சிட விரும்பினால், விசித்திரமான விஷயங்கள் நடக்கலாம். இரட்டை மேற்கோள்களை ஒற்றை அல்லது நேர்மாறாக மாற்றுவது அல்லது மேற்கோள்களிலிருந்து மாறி குறிப்புகளை எடுப்பது போன்ற எளிதில் அவை எளிதில் தீர்க்கப்படுகின்றன. «எக்கோOften விசித்திரமான விஷயங்கள் எவ்வாறு தொகுக்கப்பட்டன என்பதைப் பொறுத்து, நாம் எப்போதும் உபுண்டு அல்லது எப்போதும் ஃபெடோராவைப் பயன்படுத்தினால், அது நம்மைப் பாதிக்காது, ஆனால் விநியோகத்தை மாற்றினால் அது செய்கிறது.

அதனால்தான் நான் use ஐப் பயன்படுத்துகிறேன்வைட்டமின்«, இது எனக்கு தலைவலியைக் கொடுக்காது, மேலும் இது போல நடந்து கொள்கிறது«வைட்டமின்C சி அல்லது «இலிருந்துஅச்சுY பைதான், நீங்கள் எப்போதாவது உங்கள் ஸ்கிரிப்டை வேறொரு நிரலாக்க மொழியில் கொண்டு செல்ல விரும்பினால் இது மிகவும் முக்கியமானது.

4. பயனர் INPUT ஐப் படிக்கவும்

எங்கள் ஸ்கிரிப்ட்டின் பெயருக்குப் பிறகு மற்றும் ENTER விசையை அழுத்துவதற்கு முன்பு நாம் எழுதும் அனைத்தும் தானாகவே சிறப்பு மாறிகளில் சேமிக்கப்படும். இந்த மாறிகள் $ X வகையாகும், அங்கு X என்பது ஒரு எண்.

«$0Script எங்கள் ஸ்கிரிப்டின் பெயரையும் «இலிருந்து குறிக்கிறது$1After முடிவிலிக்கு நாம் பின்னர் எழுதிய அனைத்தும் மாறக்கூடியவை. உதாரணத்திற்கு:

பூனை << EOF >> test.sh #! / bin / bash # - * - குறியாக்கம்: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ = 2 = $ 2 \ n "EOF chmod + x script.sh ./script.sh my file.txt

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

$ 0 = ./script.sh $ 1 = எனது $ 2 = file.txt

மேற்கோள்களைப் பயன்படுத்தி "my file.txt" ஐ "$ 1" க்கு அனுப்பியிருக்கலாம்.

"வாசிப்பு" கட்டளையுடன் ஒரு பயனரின் INPUT ஐயும் படிக்கலாம், இது அளவுருவை நாம் சேமிக்க விரும்பும் மாறியை நேரடியாக குறிக்கிறது. உதாரணத்திற்கு:

printf "உங்கள் பெயர் என்ன? \ n" NAME printf ஐப் படிக்கவும் "ஹலோ, $ NAME. \ n"

5. பாஷில் கணக்கீடுகள்

அதற்கு நாம் «ஐப் பயன்படுத்தலாம்சொல்லமைப்புடன்«, சிக்கலான கணக்கீடுகளை நாம் செய்ய வேண்டியதில்லை. இரண்டு விஷயங்களை கவனிக்க வேண்டும், முதலாவது «சொல்லமைப்புடன்Number முழு எண்களை மட்டுமே ஒப்புக்கொள்கிறது, இரண்டாவதாக, பிரிவு முழு முடிவையும் அளிக்கிறது, மீதமுள்ளவற்றை நாம் பயன்படுத்தலாம் «%".

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

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

நீங்கள் தவிர்க்கலாம் «சொல்லமைப்புடன்Parent இரட்டை அடைப்புக்குறிகளைப் பயன்படுத்துதல்:

VAR2 = $ (($ VAR1 / 100%))

6. அடிப்படையில்

இது ஏற்கனவே about பற்றி மிக விரிவான முறையில் எழுதப்பட்டுள்ளதுif" 'வேறு" 'ElifConditions மற்றும் நிபந்தனைகள். அதைப் பற்றி நீங்கள் படிக்கலாம்:

• பாஷில் புரோகிராமிங்: பகுதி 1
• பாஷ்: என்றால், வேறு நிபந்தனைகள்
• ஒரு கோப்பு அல்லது கோப்புறை இருக்கிறதா இல்லையா என்பதை சரிபார்க்கவும்
• பாஷில் புரோகிராமிங்: பகுதி 2

எளிய சதுர அடைப்புக்குறிகளைப் பயன்படுத்துவதற்கான வித்தியாசத்தை நான் முன்னிலைப்படுத்த விரும்புகிறேன், «[]«, மற்றும் இரட்டை அடைப்புக்குறிகள்,«[[]]«, நிபந்தனைகளுக்கு. இரட்டை அடைப்புக்குறிகளுடன் நாம் கூடுதல் நிபந்தனைகளைப் பயன்படுத்தலாம்:

• «&&»மற்றும் மற்றும்
• «||»க்கு அல்லது

உபயோகிக்க "&&"மேலும்"||Square எளிய சதுர அடைப்புக்குறிகளுடன், ஒவ்வொரு பகுதியும் தனித்தனி சதுர அடைப்புக்குறிக்குள் பிரிக்கப்பட வேண்டும். உதவி இயக்கப்பட வேண்டுமா என்று பார்க்கும் ஸ்கிரிப்ட்டின் பகுதிக்கு பயன்படுத்தப்படும் எடுத்துக்காட்டு:

if [-z "$ 1"] || ["$ 1" == "-ம"] || ["$ 1" == "- உதவி"]]; பின்னர் fi க்கு உதவுங்கள்

பிழைகளைத் தடுக்க மேற்கோள்களில் மாறி பெயர்களை எழுதுவதிலிருந்து இது நம்மைக் காப்பாற்றுகிறது. உதாரணத்திற்கு:

[$ 1 = 1] என்றால்; பின்னர் printf "அளவுரு 1 க்கு சமம்."; fi என்றால் ["$ 1" = 1]; பின்னர் printf "அளவுரு 1 க்கு சமம்."; fi என்றால் [[$ 1 = 1]]; பின்னர் printf "அளவுரு 1 க்கு சமம்."; fi

Script.sh எந்த அளவுருக்கள் இல்லாமல் இயங்கினால், முதல் வழக்கு பிழையைக் கொடுக்கும்:

bash: [: =: unary ஆபரேட்டர் எதிர்பார்க்கப்படுகிறது

விவாதிக்கப்படாதது «வழக்கு«, எளிமைப்படுத்த பயன்படுகிறது«if«. எங்களிடம் எதுவும் இல்லாதபோது ஆரம்பத்தில் ஆரம்பிக்கலாம் «ifThe அனைத்து குறியீடும் செயல்படுத்தப்படும். நாம் ஒரு நிபந்தனையைச் சேர்த்தால் «ifTwo எங்களுக்கு இரண்டு வழக்குகள் இருக்கும், அவற்றில் ஒன்று குறியீடு தொகுதி உள்ளே இருக்கும் «ifBlock இந்த தொகுதி செயல்படுத்தப்படாத மற்ற வழக்கு.

நாம் ஒரு add ஐச் சேர்த்தால்வேறு«எங்களுக்கும் இரண்டு வழக்குகள் இருக்கும், ஆனால் இந்த இரண்டு வழக்குகளும் முந்தைய வழக்குகளிலிருந்து வேறுபட்டவை. ஏனென்றால் இப்போது இரண்டு நிபந்தனை குறியீடு தொகுதிகள், ஏ மற்றும் பி, மற்றும் ஒரு சி தொகுதி இருக்கும், இது மீதமுள்ள நிரலாகும். A அல்லது B செயல்படுத்தப்படும், மற்றும் C. முந்தைய வழக்கில் இது A மற்றும் C அல்லது C மட்டுமே.

எழுதும் நிலைமைகளைத் தவிர்க்க «if / else"உள்ளே"வேறு»மேலும் குறியீட்டின் வாசிப்பை எளிதாக்க, இது உருவாக்கப்பட்டது«Elif«. முந்தையதைப் பொறுத்து பல நிபந்தனைகள் நம்மிடம் இருக்கும்போது, ​​எடுத்துக்காட்டாக எண்களின் வரம்பு அல்லது வகை:

VAR1 = $ 1 என்றால் [[$ VAR1 = 1]]; பின்னர் printf "1 \ n" elif [[$ VAR1 = 2]]; பின்னர் printf "2 \ n" எலிஃப் [[$ VAR1 = 3]]; பின்னர் printf "3 \ n" else printf "none \ n" fi

கடைசி விஷயத்தில் «ElifConditions பல நிபந்தனைகள் படிக்கப்படும். இந்த செயல்முறை நெறிப்படுத்தப்பட்டால்:

VAR1 = case 1 வழக்கு $ VAR 1 இல்) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 அல்லது 4, இது \ n" ஐப் பொறுத்தது; *) printf "none \ n" ;; அந்த சி

இந்த விஷயத்தில் VAR1 ஒரு மாறி படிக்கப்படும், மேலும் இது ஏதேனும் ஒரு வழக்குக்கு சமமானதா என்பதைப் பார்ப்போம், இல்லையெனில், இயல்புநிலை வழக்கு "*" செயல்படுத்தப்படும். இரட்டை அரைப்புள்ளிகள் «க்கு சமம்இடைவெளி«, அவர்கள் சொல்கிறார்கள்«வழக்கு»அது முடிவுக்கு வர வேண்டும்.

7. சுழல்கள்

எந்தவொரு நிரலாக்க மொழியிலும் மிகக் குறைந்த சுழல்கள் அறியப்படுகின்றன. பாஷில் அவை «போது" 'வரை"மேலும்"ஐந்து«. இது பற்றி ஏற்கனவே வலைப்பதிவில் எழுதப்பட்டுள்ளது:

• பாஷில் புரோகிராமிங்: பகுதி 1
• பாஷில் புரோகிராமிங்: பகுதி 2

இரண்டு வகையான சுழல்கள் உள்ளன «ஐந்து«, வகையைச் சேர்ந்தவை«L LOQUESEA இல் VAR க்காக»மற்றும் சி வகை என்ன«$ for ((I = 0; I <= 10; I ++))«. இரண்டாவது வகை சுழல்கள் «ஐந்துமிகவும் பயனுள்ளதாக இருக்கும், இது வளையத்தின் தொடக்கத்தில் 3 பகுதிகளைக் கொண்டுள்ளது:

• மாறிகளின் அறிவிப்பு மற்றும் துவக்கம் (இந்த வழக்கில் ஒரு துணை மாறி "I = 0").
• மரணதண்டனை நிலை (நான் 10 ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருக்கும் வரை).
• துணை மாறியின் அதிகரிப்பு

என் கருத்துப்படி இது எல்லாவற்றிலும் மிக சக்திவாய்ந்த வளையமாகும். ஒரு உதாரணம், இது 0 முதல் 10 வரையிலான அனைத்து எண்களையும் உள்ளடக்கியது, உள்ளடக்கியது:

#! / bin / bash for ((I = 0; I <= 10; I ++)); printf "$ I \ n" முடிந்தது

8. செயல்பாடுகள்

பாஷ் எங்களை செய்ய அனுமதிக்காத சில விஷயங்கள் உள்ளன, இல்லையா? முதல் பார்வையில், பாஷ் செயல்பாடுகள் 3 காரியங்களைச் செய்வதிலிருந்து உங்களைத் தடுக்கின்றன: செயல்பாடுகளில் உள்ளூர் மாறிகள் அறிவித்தல், செயல்பாடுகளுக்கு அளவுருக்களை அனுப்புதல் மற்றும் அளவுருக்களைத் திருப்புதல். எல்லாவற்றிற்கும் ஒரு தீர்வு உள்ளது.

அப்படி எதுவும் செய்ய வேண்டாம்:

#! / bin / bash VAR = 1 printc "$ VAR \ n" செயல்பாடு ஹலோ () {VAR = 2 printf "$ VAR \ n"} ஹலோ printf "$ VAR \ n"

இது 1, 2 மற்றும் 2 திரைக்கு அச்சிடுகிறது.

உள்ளூர் மாறிகள் அறிவிக்க, add சேர்க்கவும்உள்ளூர்Dec அறிவிக்கும் போது:

#!

இது திரையில் 1, 1, 2, 1 ஐ அச்சிடுகிறது.

ஒரு செயல்பாட்டிற்கு அளவுருக்களை எவ்வாறு அனுப்புவது?

#! / பின் / பாஷ் # - * - குறியாக்கம்: யுடிஎஃப் -8 - * - செயல்பாடு ஹலோ () {printf "ஹலோ $ 1 \ n"}

printf "உங்கள் பெயர் என்ன? \ n"
VAR1 ஐப் படிக்கவும்
ஹலோ $ VAR1

அளவுருக்கள் எவ்வாறு திரும்பப் பெறப்படுகின்றன?

#! / bin / bash # - * - குறியாக்கம்: UTF-8 - * - செயல்பாடு ஹலோ () {printf "ஹலோ ஹோலிடா"} printf "உங்கள் பெயர் என்ன? printf "$ VAR1 $ VAR1 \ n"

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

9. கெட்டாப்ஸ்

சிக்கலான ஸ்கிரிப்ட்களை உருவாக்க பாஷைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய கடைசி விஷயங்களில் ஒன்று «கெட்டப்புகள்«. வரிசையைப் பொருட்படுத்தாமல் ஸ்கிரிப்டுக்கு விருப்பங்களை அனுப்ப இது பயன்படுகிறது. ஒரே தீங்கு என்னவென்றால், இது குறுகிய விருப்பங்களை மட்டுமே பாதிக்கிறது:

#! / bin / bash # - * - குறியாக்கம்: UTF-8 - * - VARC = 0 செயல்பாட்டு உதவி () {printf "உதவி செய்தி \ n" வெளியேறு} என்றால் [[-z $ 1]]; getopts போது fi க்கு உதவுங்கள்: ha: b: c OPT; வழக்கு $ OPT இல் h) உதவி; :) உதவி ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) உதவி ;; esac done # VARA, VARB மற்றும் VARC உடன் # விஷயங்களைச் செய்யும் ஸ்கிரிப்ட்டின் பிரதான தொகுதி

«கெட்டோப்ட்ஸ்The விருப்பங்களை ஒவ்வொன்றாகப் படிக்கிறது, எனவே ஒரு வளையம் தேவை.

Using ஐப் பயன்படுத்தி அனுப்பக்கூடிய 2 வகையான விருப்பங்கள் உள்ளனகெடோப்ட்ஸ்":

• கொடிகள் எனப்படும் அளவுருக்கள், இந்த விஷயத்தில் -c அல்லது -h. நாம் பயன்படுத்த விரும்பும் கடிதத்துடன் அவை குறிப்பிடப்பட்டுள்ளன. அவை பூலியன் மாறிகள் போன்றவை, «உண்மை»(உள்ளன) அல்லது«தவறான"(அவர்கள் இங்கே இல்லை).
• தொடர்புடைய வாதங்களுடன் அளவுருக்கள், -ஒரு எதையும், -பி எதையும். கீழே உள்ள பெருங்குடலுடன் நாம் விரும்பும் கடிதத்துடன் அவை குறிப்பிடப்பட்டுள்ளன. வாதம் OPTARG இல் சேமிக்கப்பட்டுள்ளது (இந்த பெயர் மாற்ற முடியாதது).

இந்த ஸ்கிரிப்ட் என்ன செய்கிறது?

எந்த விருப்பமும் அனுப்பப்படாதபோது, ​​"-h" அளவுரு கடந்து செல்லும்போது, ​​தவறான அளவுரு கடந்து செல்லும் போது (எடுத்துக்காட்டாக "-x", இது "\?" ஆல் செய்யப்படுகிறது) அல்லது ஒரு போது எந்த வாதமும் இல்லாத செல்லுபடியாகும் அளவுரு (":"). மீதமுள்ள நிகழ்வுகளில் இது VARC இல் 1-ஆக "-c" இருப்பதைக் காப்பாற்றுகிறது, மேலும் VARA மற்றும் VARB இல் "-a" மற்றும் "-b" உடன் அனுப்பப்பட்ட மதிப்புகள்.