agwebrunner.com

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

மாறிகள் 101

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

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

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

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

நாங்கள் நான்கு சரம் மாறிகள் மற்றும் ஒரு எண் மாறியை உருவாக்குவோம்,இந்த வருடம்:

me = டேவ்

my_boost = லினக்ஸ்

அவரை = போபியே

his_boost = கீரை

this_year = 2019

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

எதிரொலி $ my_name

எதிரொலி $ my_boost

எதிரொலி $ this_year

எங்கள் எல்லா மாறிகளையும் ஒரே நேரத்தில் பயன்படுத்தலாம்:

எதிரொலி "$ my_boost $ எனக்கு $ as_boost $ him (c) $ this_year"

மாறிகளின் மதிப்புகள் அவற்றின் பெயர்களை மாற்றுகின்றன. நீங்கள் மாறிகளின் மதிப்புகளையும் மாற்றலாம். மாறிக்கு ஒரு புதிய மதிப்பை ஒதுக்க,my_boost, அதன் முதல் மதிப்பை நீங்கள் ஒதுக்கும்போது நீங்கள் செய்ததை மீண்டும் செய்கிறீர்கள்:

my_boost = டெக்கீலா

முந்தைய கட்டளையை மீண்டும் இயக்கினால், இப்போது வேறு முடிவைப் பெறுவீர்கள்:

எதிரொலி "$ my_boost $ எனக்கு $ as_boost $ him (c) $ this_year"

எனவே, அதே மாறிகளைக் குறிக்கும் அதே கட்டளையைப் பயன்படுத்தலாம் மற்றும் மாறிகளில் உள்ள மதிப்புகளை மாற்றினால் வெவ்வேறு முடிவுகளைப் பெறலாம்.

மாறிகளை மேற்கோள் காட்டுவது பற்றி பின்னர் பேசுவோம். இப்போதைக்கு, நினைவில் கொள்ள வேண்டிய சில விஷயங்கள் இங்கே:

• ஒற்றை மேற்கோள்களில் ஒரு மாறி ' ஒரு நேரடி சரமாக கருதப்படுகிறது, ஆனால் ஒரு மாறி அல்ல.
• மேற்கோள் மதிப்பெண்களில் மாறுபாடுகள் " மாறிகளாக கருதப்படுகின்றன.
• ஒரு மாறியில் வைத்திருக்கும் மதிப்பைப் பெற, நீங்கள் டாலர் அடையாளத்தை வழங்க வேண்டும் $.
• டாலர் அடையாளம் இல்லாத மாறி $ மாறியின் பெயரை மட்டுமே வழங்குகிறது.

ஏற்கனவே உள்ள மாறி அல்லது மாறிகளின் எண்ணிக்கையிலிருந்து அதன் மதிப்பை எடுக்கும் ஒரு மாறியை நீங்கள் உருவாக்கலாம். பின்வரும் கட்டளை எனப்படும் புதிய மாறியை வரையறுக்கிறது பானம்_அது_உங்கள், மற்றும் அதன் ஒருங்கிணைந்த மதிப்புகளை ஒதுக்குகிறது my_boost மற்றும் இந்த வருடம் மாறிகள்:

drink_of-the_Year = "$ my_boost $ this_year"

ஆண்டு பானம் எதிரொலி

ஸ்கிரிப்ட்களில் மாறிகள் எவ்வாறு பயன்படுத்துவது

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

இதை உரை கோப்பில் தட்டச்சு செய்து, பின்னர் சேமிக்கவும் fcnt.sh (“கோப்பு எண்ணிக்கை” க்கு):

#! / bin / bash folder_to_count = / dev file_count = $ (ls $ folder_to_count | wc -l) $ folder_to_count இல் $ file_count கோப்புகளை எதிரொலிக்கிறது

நீங்கள் ஸ்கிரிப்டை இயக்குவதற்கு முன், கீழே காட்டப்பட்டுள்ளபடி அதை இயக்கக்கூடியதாக மாற்ற வேண்டும்:

chmod + x fcnt.sh

ஸ்கிரிப்டை இயக்க பின்வரும்வற்றைத் தட்டச்சு செய்க:

./fcnt.sh

இது கோப்புகளின் எண்ணிக்கையை அச்சிடுகிறது / dev அடைவு. இது எவ்வாறு செயல்படுகிறது என்பது இங்கே:

• எனப்படும் மாறி கோப்புறை_க்கு_ எண்ணிக்கை வரையறுக்கப்பட்டுள்ளது, மேலும் இது “/ dev” என்ற சரத்தை வைத்திருக்க அமைக்கப்பட்டுள்ளது.
• மற்றொரு மாறி, என்று அழைக்கப்படுகிறதுfile_count, வரையறுக்கப்படுகிறது. இந்த மாறி அதன் மதிப்பை ஒரு கட்டளை மாற்றிலிருந்து எடுக்கிறது. அடைப்புக்குறிக்கு இடையிலான கட்டளை சொற்றொடர் இது $( ). டாலர் அடையாளம் இருப்பதைக் கவனியுங்கள் $ முதல் அடைப்புக்கு முன். இது கட்டமைக்கிறது $( ) அடைப்புக்குறிக்குள் உள்ள கட்டளைகளை மதிப்பிடுகிறது, பின்னர் அவற்றின் இறுதி மதிப்பை வழங்குகிறது. இந்த எடுத்துக்காட்டில், அந்த மதிப்பு file_count மாறி. இதுவரை file_count மாறி கவலை, அது ஒரு மதிப்பு வைத்திருக்க வேண்டும்; மதிப்பு எவ்வாறு பெறப்பட்டது என்பது குறித்து அது கவலைப்படவில்லை.
• கட்டளை மாற்றீட்டில் மதிப்பிடப்பட்ட கட்டளை ஒரு செய்கிறது ls இல் உள்ள கோப்பகத்தில் கோப்பு பட்டியல் கோப்புறை_க்கு_ எண்ணிக்கை மாறி, இது “/ dev” என அமைக்கப்பட்டுள்ளது. எனவே, ஸ்கிரிப்ட் “ls / dev” கட்டளையை இயக்குகிறது.
• இந்த கட்டளையின் வெளியீடு குழாய் பதிக்கப்படுகிறது wcகட்டளை. தி -l (வரி எண்ணிக்கை) விருப்பம் காரணங்கள்wc இலிருந்து வெளியீட்டில் உள்ள வரிகளின் எண்ணிக்கையை எண்ணls கட்டளை. ஒவ்வொரு கோப்பும் ஒரு தனி வரியில் பட்டியலிடப்பட்டுள்ளதால், இது “/ dev” கோப்பகத்தில் உள்ள கோப்புகள் மற்றும் துணை அடைவுகளின் எண்ணிக்கை. இந்த மதிப்பு ஒதுக்கப்பட்டுள்ளது file_count மாறி.
• இறுதி வரி முடிவை வெளியிடுவதற்கு எதிரொலியைப் பயன்படுத்துகிறது.

ஆனால் இது “/ dev” கோப்பகத்திற்கு மட்டுமே செயல்படும். எந்தவொரு கோப்பகத்திலும் ஸ்கிரிப்டை எவ்வாறு செயல்படுத்துவது? இது ஒரு சிறிய மாற்றம் மட்டுமே.

ஸ்கிரிப்ட்களில் கட்டளை வரி அளவுருக்களை எவ்வாறு பயன்படுத்துவது

போன்ற பல கட்டளைகள் ls மற்றும் wc, கட்டளை வரி அளவுருக்களை எடுத்துக் கொள்ளுங்கள். இவை கட்டளைக்கு தகவல்களை வழங்குகின்றன, எனவே நீங்கள் என்ன செய்ய விரும்புகிறீர்கள் என்பது அதற்குத் தெரியும். உனக்கு வேண்டுமென்றால்ls உங்கள் வீட்டு அடைவில் வேலை செய்வதற்கும், மறைக்கப்பட்ட கோப்புகளைக் காண்பிப்பதற்கும், நீங்கள் பின்வரும் கட்டளையைப் பயன்படுத்தலாம், அங்கு டில்ட் ~ மற்றும் இந்த -அ (அனைத்தும்) விருப்பம் கட்டளை வரி அளவுருக்கள்:

ls ~ -a

எங்கள் ஸ்கிரிப்ட்கள் கட்டளை வரி அளவுருக்களை ஏற்கலாம். அவை குறிப்பிடப்படுகின்றன $1 முதல் அளவுருவுக்கு, $2 இரண்டாவது, மற்றும் பல $9 ஒன்பதாவது அளவுருவுக்கு. (உண்மையில், ஒரு உள்ளது $0, அதே போல், ஆனால் அது எப்போதும் ஸ்கிரிப்டை வைத்திருக்க ஒதுக்கப்பட்டுள்ளது.)

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

#! / bin / bash folder_to_count = $ 1 file_count = $ (ls $ folder_to_count | wc -l) $ folder_to_count இல் $ file_count கோப்புகளை எதிரொலிக்கிறது

இந்த நேரத்தில், தி கோப்புறை_க்கு_ எண்ணிக்கை மாறி முதல் கட்டளை வரி அளவுருவின் மதிப்பை ஒதுக்குகிறது, $1.

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

ஸ்கிரிப்டை எவ்வாறு இயக்க முடியும் என்பதை இங்கே காணலாம்:

chmod + x fcnt2.sh

இப்போது, ​​சில கோப்பகங்களுடன் முயற்சிக்கவும். முன்பு இருந்ததைப் போலவே நீங்கள் பெறுகிறீர்கள் என்பதை உறுதிப்படுத்த முதலில் “/ dev” செய்யலாம். பின்வருவனவற்றைத் தட்டச்சு செய்க:

./fnct2.sh / dev

./fnct2.sh / போன்றவை

./fnct2.sh / பின்

“/ Dev” கோப்பகத்திற்கு முன்பு இருந்த அதே முடிவை (207 கோப்புகள்) பெறுவீர்கள். இது ஊக்கமளிக்கிறது, மேலும் ஒவ்வொரு கட்டளை வரி அளவுருக்களுக்கும் அடைவு-குறிப்பிட்ட முடிவுகளைப் பெறுவீர்கள்.

ஸ்கிரிப்டைக் குறைக்க, நீங்கள் மாறியைக் கொண்டு அனுப்பலாம்,கோப்புறை_க்கு_ எண்ணிக்கை, ஒட்டுமொத்தமாக, மற்றும் குறிப்பு $1 முழுவதும், பின்வருமாறு:

#! / bin / bash file_count = $ (ls $ 1 wc -l) $ 1 இல் $ file_count கோப்புகளை எதிரொலிக்கிறது

சிறப்பு மாறிகள் வேலை

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

பின்வருபவை பிற சிறப்பு முன்னமைக்கப்பட்ட மாறிகள்:

• $#: ஸ்கிரிப்டுக்கு எத்தனை கட்டளை வரி அளவுருக்கள் அனுப்பப்பட்டன.
• $@: அனைத்து கட்டளை வரி அளவுருக்கள் ஸ்கிரிப்டுக்கு அனுப்பப்பட்டன.
• $?: இயங்க வேண்டிய கடைசி செயல்முறையின் வெளியேறும் நிலை.
• $$: தற்போதைய ஸ்கிரிப்ட்டின் செயல்முறை ஐடி (பிஐடி).
• $ USER: ஸ்கிரிப்டை இயக்கும் பயனரின் பயனர்பெயர்.
• OST HOSTNAME: ஸ்கிரிப்டை இயக்கும் கணினியின் ஹோஸ்ட்பெயர்.
• $ இரண்டாவது: ஸ்கிரிப்ட் இயங்கும் விநாடிகளின் எண்ணிக்கை.
• AND சீரற்ற: சீரற்ற எண்ணை வழங்குகிறது.
• $ லினெனோ: ஸ்கிரிப்ட்டின் தற்போதைய வரி எண்ணை வழங்குகிறது.

அவை அனைத்தையும் ஒரே ஸ்கிரிப்ட்டில் பார்க்க விரும்புகிறீர்கள், இல்லையா? உன்னால் முடியும்! பின்வருவனவற்றை உரை கோப்பாக சேமிக்கவும்,special.sh:

#! / bin / bash echo "command # கட்டளை வரி அளவுருக்கள்" எதிரொலி "அவை: $ @" எதிரொலி "அளவுரு 1 என்பது: $ 1" எதிரொலி "ஸ்கிரிப்ட் அழைக்கப்படுகிறது: $ 0" # எந்தவொரு பழைய செயல்முறையும் இதனால் நாங்கள் புகாரளிக்க முடியும் வெளியேறும் நிலையில் pwd எதிரொலி "pwd திரும்ப $?" எதிரொலி "இந்த ஸ்கிரிப்ட்டில் செயல்முறை ஐடி உள்ளது $$" எதிரொலி "ஸ்கிரிப்ட் $ USER" எதிரொலி "ஆல் தொடங்கப்பட்டது இது $ HOSTNAME" தூக்கம் 3 எதிரொலி "இல் இயங்குகிறது $ SECONDS விநாடிகள் இயங்கி வருகிறது" எதிரொலி "சீரற்ற எண்: $ ரேண்டம்" எதிரொலி "இது வரி எண் $ ஸ்கிரிப்டின் LINENO"

அதை இயக்கக்கூடியதாக மாற்ற பின்வரும்வற்றைத் தட்டச்சு செய்க:

chmod + x special.sh

இப்போது, ​​கீழே காட்டப்பட்டுள்ளபடி, வெவ்வேறு கட்டளை வரி அளவுருக்கள் மூலம் அதை இயக்கலாம்.

சுற்றுச்சூழல் மாறிகள்

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

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

env | குறைவாக

நீங்கள் பட்டியலை உருட்டினால், உங்கள் ஸ்கிரிப்ட்களில் குறிப்பிட பயனுள்ளதாக இருக்கும் சிலவற்றை நீங்கள் காணலாம்.

மாறிகள் ஏற்றுமதி செய்வது எப்படி

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

முதலில், பின்வருவனவற்றை கோப்பு பெயருடன் சேமிக்கவும்script_one.sh:

#! / bin / bash first_var = alpha second_var = bravo # அவற்றின் மதிப்புகளை எதிரொலிக்கிறது "$ 0: first_var = $ first_var, second_var = $ second_var" export first_var export second_var ./script_two.sh # அவற்றின் மதிப்புகளை மீண்டும் சரிபார்க்கவும் "$ 0: first_var = $ first_var, second_var = $ second_var "

இது இரண்டு மாறிகள் உருவாக்குகிறது, முதல்_வார் மற்றும் இரண்டாவது_வார், அது சில மதிப்புகளை ஒதுக்குகிறது. இது முனைய சாளரத்தில் அச்சிடுகிறது, மாறிகள் ஏற்றுமதி செய்கிறது மற்றும் அழைப்புகள் script_two.sh. எப்பொழுது script_two.sh இந்த ஸ்கிரிப்டுக்கு செயல்முறை ஓட்டம் திரும்பும், அது மீண்டும் முனைய சாளரத்தில் மாறிகள் அச்சிடுகிறது. பின்னர், அவை மாறிவிட்டனவா என்பதை நீங்கள் பார்க்கலாம்.

நாம் பயன்படுத்தும் இரண்டாவது ஸ்கிரிப்ட் script_two.sh. இதுதான் ஸ்கிரிப்ட்script_one.shஅழைப்புகள். பின்வருவனவற்றைத் தட்டச்சு செய்க:

#! / bin / bash # அவற்றின் மதிப்புகளை எதிரொலிக்கவும் "$ 0: first_var = $ first_var, second_var = $ second_var" # புதிய மதிப்புகளை அமைக்கவும் first_var = charlie second_var = delta # அவற்றின் மதிப்புகளை மீண்டும் சரிபார்க்கவும் "$ 0: first_var = $ first_var, second_var = $ second_var "

இந்த இரண்டாவது ஸ்கிரிப்ட் இரண்டு மாறிகள் மதிப்புகளை அச்சிட்டு, அவர்களுக்கு புதிய மதிப்புகளை ஒதுக்குகிறது, பின்னர் அவற்றை மீண்டும் அச்சிடுகிறது.

இந்த ஸ்கிரிப்ட்களை இயக்க, அவற்றை இயக்கக்கூடியதாக மாற்ற பின்வரும்வற்றை தட்டச்சு செய்ய வேண்டும்:

chmod + x script_one.sh chmod + x script_two.sh

இப்போது, ​​தொடங்க பின்வரும்வற்றைத் தட்டச்சு செய்க script_one.sh:

./script_one.sh

வெளியீடு இது நமக்கு சொல்கிறது:

• script_one.sh மாறிகள் மதிப்புகளை அச்சிடுகிறது, அவை ஆல்பா மற்றும் பிராவோ.
• script_two.sh மாறிகள் (ஆல்பா மற்றும் பிராவோ) பெறப்பட்டதைப் போல அவை பெறுகின்றன.
• script_two.sh அவற்றை சார்லி மற்றும் டெல்டாவாக மாற்றுகிறது.
• script_one.sh மாறிகளின் மதிப்புகளை அச்சிடுகிறது, அவை இன்னும் ஆல்பா மற்றும் பிராவோ.

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

மாறிகளை எவ்வாறு மேற்கோள் காட்டுவது

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

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

இங்கே ஒரு எடுத்துக்காட்டு:

site_name = எப்படி-எப்படி கீக்

ஒரு புதிய கட்டளை தொடங்குகிறது என்பதற்கான அறிகுறியாக “கீக்” க்கு முன் பாஷ் இடத்தைப் பார்க்கிறார். அத்தகைய கட்டளை எதுவும் இல்லை என்று அது தெரிவிக்கிறது, மேலும் அந்த வரியை கைவிடுகிறது. எதிரொலி என்று நமக்குக் காட்டுகிறது site_name மாறி எதுவும் இல்லை-“எப்படி-எப்படி” உரை கூட இல்லை.

கீழே காட்டப்பட்டுள்ளபடி, மதிப்பைச் சுற்றியுள்ள மேற்கோள் குறிகளுடன் மீண்டும் முயற்சிக்கவும்:

site_name = "எப்படி-எப்படி கீக்"

இந்த நேரத்தில், இது ஒரு மதிப்பாக அங்கீகரிக்கப்பட்டு சரியாக ஒதுக்கப்பட்டுள்ளது site_name மாறி.

எதிரொலி உங்கள் நண்பர்

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

நீங்கள் Enter ஐ அழுத்தி, பாஷ் கட்டளைகளின் வரியை இயக்குவதற்கு முன், அதை முயற்சிக்கவும் எதிரொலி அதன் முன். இந்த வழியில், என்ன நடக்கப் போகிறது என்பதை நீங்கள் உறுதிப்படுத்திக் கொள்ளலாம். தொடரியல் நீங்கள் செய்த எந்த தவறுகளையும் நீங்கள் பிடிக்கலாம்.