பேஷ் ஸ்கிரிப்டை எப்படி பிழைதிருத்தம் செய்வது?

How Debug Bash Script




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

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







லினக்ஸில் உள்ள ஷெல் என்றால் என்ன?

உங்கள் கணினியை துவக்கும்போது, ​​கர்னல் இணைக்கப்பட்ட வன்பொருள் பற்றிய தகவலைப் பெறுகிறது மற்றும் பிற இணைக்கப்பட்ட கூறுகளை தொடர்பு கொள்ள அனுமதிக்கிறது. அது தவிர, இது நினைவகம், CPU ஐ நிர்வகிக்கிறது மற்றும் எந்த புதிய புறத்தையும் அங்கீகரிக்கிறது. மொத்தத்தில், கர்னல் எந்த இயக்க முறைமையின் முதுகெலும்பாகும். ஆனால் நீங்கள் எப்போதாவது கர்னலுடன் நேரடியாக தொடர்பு கொள்ள நினைத்திருக்கிறீர்களா, ஒரு குறிப்பிட்ட பணியைச் செய்ய கட்டளையிடுகிறீர்களா? அதைச் செய்வது கூட நடைமுறைக்கு சாத்தியமா? முற்றிலும்! ஒரு ஷெல்லின் உதவியுடன், ஒரு ஊடாடும் இடைமுகத்துடன் கூடிய கணினி நிரல், எவரும் கர்னலை இயக்க முடியும். ஷெல் மனிதர்களை கர்னலுடன் தொடர்புகொண்டு எந்தப் பணிகளையும் செய்ய அறிவுறுத்துகிறது.



யூனிக்ஸில், இரண்டு முக்கிய குண்டுகள் உள்ளன பார்ன் ஷெல் மற்றும் சி ஷெல் . இந்த இரண்டு வகைகளும் அவற்றின் துணைப்பிரிவுகளைக் கொண்டுள்ளன. பல்வேறு வகையான பார்ன் குண்டுகள் உள்ளன கார்ன் ஷெல் (ksh), அல்ம்கிஸ்ட் ஷெல் (சாம்பல்), பார்ன் மீண்டும் ஷெல் (பாஷ்), மற்றும் Z ஷெல் (zsh) . அதே நேரத்தில், சி ஷெல் அதன் சொந்த துணைப்பிரிவுகளைக் கொண்டுள்ளது சி ஷெல் (csh) மற்றும் TENEX C ஷெல் (tcsh) . மேலே குறிப்பிட்டுள்ளபடி, அனைத்து குண்டுகளிலும், பேஷ் (பார்ன் மீண்டும் ஷெல்) மிகவும் பரவலாகப் பயன்படுத்தப்படும் ஷெல் மற்றும் அதன் செயல்திறன் மற்றும் பயனர் நட்பு காரணமாக பல லினக்ஸ் விநியோகங்களில் பெட்டியிலிருந்து வெளியே வருகிறது.



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





ஷெல் ஸ்கிரிப்ட் என்றால் என்ன:

ஷெல்லின் அடிப்படை யோசனையை நாங்கள் கற்றுக்கொண்டதால், இப்போது ஷெல் ஸ்கிரிப்டிங்கை நோக்கி செல்லலாம். ஷெல் ஸ்கிரிப்ட் என்பது ஒரு கணிப்பொறி நிரலாகும், இது ஒரு குறிப்பிட்ட செயல்பாட்டைச் செய்ய ஒரு மொழிபெயர்ப்பாளராக செயல்படும் ஒரு ஷெல்லில் பல கட்டளைகளைச் செயல்படுத்துகிறது. மேலே விவாதிக்கப்பட்டபடி, 2 குறிப்பிட்ட வகையான குண்டுகள் உள்ளன. இருப்பினும், இந்த வழிகாட்டி பார்ன் அகெய்ன் ஷெல் (பாஷ்) மீது கவனம் செலுத்துகிறது.
எனவே பாஷ் ஸ்கிரிப்ட் என்றால் என்ன? லினக்ஸில், அனைத்து பாஷ் கட்டளைகளும் சேமிக்கப்படும் /usr /பின் மற்றும் /பின் கோப்புறைகள். உதாரணமாக, நீங்கள் கட்டளையை இயக்கும்போதெல்லாம், பேஷ் கோப்பகத்தில் இருக்கிறதா இல்லையா என்று தேடுகிறது. கோப்பகங்களில் வேறு ஏதேனும் பிழை இருப்பதை கண்டால் கட்டளை செயல்படுத்தப்படும்.

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



பாஷ் ஸ்கிரிப்டிங்கில் உள்ள பிழைகள் என்ன:

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

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

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

பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைத்திருத்தம் செய்வது:

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

குறியீடுகளை பிழைதிருத்தம் செய்ய லினக்ஸில் பல்வேறு கருவிகள் உள்ளன, எடுத்துக்காட்டாக, GNU Debugger aka gdb. GDB போன்ற கருவிகள் பைனரிகளாக தொகுக்கும் நிரலாக்க மொழிகளுக்கு உதவியாக இருக்கும். பாஷ் ஒரு எளிமையான விளக்க மொழி என்பதால், அதை பிழைத்திருத்தத்திற்கு கனமான கருவிகள் தேவையில்லை.

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

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

  1. பேஷ் ஸ்கிரிப்டை இயக்குவதன் மூலம் பிழைதிருத்தம் செய்வது எப்படி வினைச்சொல் -v விருப்பம்
  2. பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எப்படி பிழைதிருத்தம் செய்வது xtrace -x விருப்பம்
  3. பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எப்படி பிழைதிருத்தம் செய்வது noexec -n விருப்பம்
  4. எப்படி அடையாளம் காண்பது அமைக்கப்படாத மாறிகள் பேஷ் ஸ்கிரிப்டை பிழைதிருத்தம் செய்யும் போது
  5. எப்படி பிழைதிருத்தம் செய்வது குறிப்பிட்ட பகுதி பாஷ் ஸ்கிரிப்ட்டின்
  6. இதைப் பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது பொறி கட்டளை
  7. நீக்குவதன் மூலம் பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது கோப்பு குளோபிங் பயன்படுத்தி -f விருப்பம்
  8. எப்படி இணை ஷெல் ஸ்கிரிப்டை பிழைத்திருத்த விருப்பங்கள்
  9. எப்படி பிழைத்திருத்த அறிக்கையை திருப்பி விடுங்கள் ஒரு கோப்பிற்கு

எனவே பேஷ் ஸ்கிரிப்டை பிழைத்திருத்தமாக பேஷில் உள்ள பல்வேறு நுட்பங்களைப் பார்ப்போம்:

1. verbose -v விருப்பத்தை இயக்குவதன் மூலம் பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைத்திருத்தம் செய்வது:

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

#! /பின்/பேஷ்
வெளியே எறிந்தார் எண் 1 ஐ உள்ளிடவும்
படிஇலக்கம் 1
வெளியே எறிந்தார் எண் 2 ஐ உள்ளிடவும்
படிஎண் 2
என்றால் [ '$ எண் 1' -ஜிடி '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 ஐ விட அதிகம்'
எலிஃப் [ '$ எண் 1' -எக்யூ '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 க்கு சமம்'
வேறு
வெளியே எறிந்தார் 'எண் 2 எண் 1 ஐ விட அதிகம்'
இரு

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

$சூடோபொருத்தமானநிறுவு நான் வந்தேன்

இதைப் பயன்படுத்தி பேஷ் ஸ்கிரிப்ட் கோப்பை உருவாக்கவும்:

$நான் வந்தேன்b_script.sh

நீங்கள் விம் எடிட்டருக்கு புதியவராக இருந்தால், நீங்கள் கற்றுக்கொள்ள பரிந்துரைக்கிறேன் விம் எடிட்டரை எவ்வாறு பயன்படுத்துவது தொடர்வதற்கு முன்.

இப்போது, ​​ஸ்கிரிப்டுக்குத் திரும்பி, ஸ்கிரிப்டைப் பயன்படுத்தி இயக்கவும் -வி விருப்பம்:

$பேஷ் -விb_script.sh

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

#! / பின் / பேஷ் -வி

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

#! /பின்/பேஷ்
அமை -வி

மேலே விவாதிக்கப்பட்ட எந்த முறைகளும் வினைச்சொல்லை இயக்கலாம்.

2 xtrace -x விருப்பத்தைப் பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது:

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

$பேஷ் -எக்ஸ்b_script.sh

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

3 noexec -n விருப்பத்தைப் பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது:

தொடரியல் பிழைகள் பிழைகளின் முக்கிய காரணங்களில் ஒன்றாகும். பாஷ் ஸ்கிரிப்டை தொடரியல் பிழைத்திருத்தத்திற்கு, நாங்கள் பயன்படுத்துகிறோம் noexec (செயல்படுத்தல் இல்லை) முறை. Noexec பயன்முறையில் பயன்படுத்தப்படும் விருப்பம் -என். இது குறியீட்டின் தொடரியல் பிழைகளை மட்டுமே செயல்படுத்துவதற்கு பதிலாக காண்பிக்கும். குறியீட்டை பிழைதிருத்தம் செய்ய மிகவும் பாதுகாப்பான அணுகுமுறை. செயல்படுத்துவோம் b_script.sh உடன் மீண்டும் -என் விருப்பம்:

$பேஷ் -என்b_script.sh

தொடரியல் பிழை இல்லை என்றால் குறியீட்டை செயல்படுத்த முடியாது. இப்போது, ​​எங்கள் குறியீட்டை மாற்றியமைப்போம்:

#! /பின்/பேஷ்

வெளியே எறிந்தார் எண் 1 ஐ உள்ளிடவும்
படிஇலக்கம் 1
வெளியே எறிந்தார் எண் 2 ஐ உள்ளிடவும்
படிஎண் 2
என்றால் [ '$ எண் 1' -ஜிடி '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 ஐ விட அதிகம்'
எலிஃப் [ '$ எண் 1' -எக்யூ '$ எண் 2' ]
#பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 க்கு சமம்'
வேறு
வெளியே எறிந்தார் 'எண் 2 எண் 1 ஐ விட அதிகம்'
இரு

நான் கருத்து தெரிவிக்கிறேன் பிறகு பிறகு எலிஃப் . இப்போது, ​​-n இயக்கத்துடன் b_script.sh கையால் எழுதப்பட்ட தாள்:

$பேஷ் -என்b_script.sh

எதிர்பார்த்தபடி, அது பிழையை தெளிவாக அடையாளம் கண்டு அதை முனையத்தில் காட்டும்.

4 பேஷ் ஸ்கிரிப்டை பிழைதிருத்தம் செய்யும் போது அமைக்கப்படாத மாறிகளை எவ்வாறு கண்டறிவது:

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

#! /பின்/பேஷ்
வெளியே எறிந்தார் எண் 1 ஐ உள்ளிடவும்
படிஇலக்கம் 1
வெளியே எறிந்தார் எண் 2 ஐ உள்ளிடவும்
படிஎண் 2
என்றால் [ '$ num1' -ஜிடி '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 ஐ விட அதிகம்'
எலிஃப் [ '$ எண் 1' -எக்யூ '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 க்கு சமம்'
வேறு
வெளியே எறிந்தார் 'எண் 2 எண் 1 ஐ விட அதிகம்'
இரு

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

$பேஷ் -உb_script.sh

வெளியீடு ஒரு அமைக்கப்படாத மாறியின் பெயரை அடையாளம் கண்டு வெளிப்படையாகக் காட்டுகிறது.

5. பாஷ் ஸ்கிரிப்ட்டின் குறிப்பிட்ட பகுதியை எவ்வாறு பிழைதிருத்தம் செய்வது:

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

#! /பின்/பேஷ்
வெளியே எறிந்தார் எண் 1 ஐ உள்ளிடவும்
படிஇலக்கம் 1
வெளியே எறிந்தார் எண் 2 ஐ உள்ளிடவும்
படிஎண் 2
அமை -எக்ஸ்
என்றால் [ '$ எண்' -ஜிடி '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 ஐ விட அதிகம்'
எலிஃப் [ '$ எண் 1' -எக்யூ '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 க்கு சமம்'
வேறு
வெளியே எறிந்தார் 'எண் 2 எண் 1 ஐ விட அதிகம்'
இரு
அமை+ x

இப்போது, ​​ஸ்கிரிப்டைப் பயன்படுத்தி இயக்கவும் பேஷ் b_script.sh .

வெளியீடு என்றால் குறிப்பிடப்பட்ட நிபந்தனைகள் இருந்தால் மட்டுமே பிழைதிருத்தம் செய்யப்படுகிறது.

6. பொறி கட்டளையைப் பயன்படுத்தி பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது:

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

#! /பின்/பேஷ்
பொறி 'எதிரொலி' வரி $ {LINENO}: முதல் எண் $ number1, இரண்டாவது எண் $ number2 மற்றும் தொகை $ தொகை ''பிழை
வெளியே எறிந்தார் 'முதல் எண்ணை உள்ளிடவும்'
படிஇலக்கம் 1
வெளியே எறிந்தார் இரண்டாவது எண்ணை உள்ளிடவும்
படிஎண் 2
தொகை= $[எண் 1 + எண் 2]
வெளியே எறிந்தார் தொகை ஆகும்$ தொகை'

தி பொறி உடன் கட்டளை பிழை சமிக்ஞை மாறிகளின் நிலையை காட்டுகிறது இலக்கம் 1 , எண் 2 மற்றும் தொகை பின்வரும் வெளியீடு படத்தில் காட்டப்பட்டுள்ளபடி ஒவ்வொரு வரியையும் செயல்படுத்திய பின்:

பயனர் இன்னும் உள்ளீட்டை உள்ளிடாததால் மஞ்சள் தொகுதிகள் வெற்று இடங்கள்; பயனர் மதிப்புகளை உள்ளிடும்போது இந்த இடங்கள் நிரப்பப்படும். பாஷ் ஸ்கிரிப்ட்களை பிழைத்திருத்தத்திலும் இந்த முறை மிகவும் உதவியாக இருக்கும்.

7. -f விருப்பத்தைப் பயன்படுத்தி கோப்பு குளோபிங்கை நீக்குவதன் மூலம் பேஷ் ஸ்கிரிப்டை எவ்வாறு பிழைதிருத்தம் செய்வது:

கோப்பு குளோபிங் என்பது வைல்ட்கார்டு எழுத்துகளுடன் கோப்புகளைக் கண்டுபிடிக்கும் செயல்முறையாகும், அதாவது. * மற்றும் ? . பல சூழ்நிலைகளில், பிழைத்திருத்தத்தின் போது நீங்கள் கோப்புகளை விரிவாக்க தேவையில்லை. இதுபோன்ற சந்தர்ப்பங்களில், கோப்பைப் பயன்படுத்துவதை நீங்கள் தடுக்கலாம் -f விருப்பம். ஒரு ஸ்கிரிப்ட் மூலம் புரிந்துகொள்வோம் fglobe_script.sh :

#! /பின்/பேஷ்
வெளியே எறிந்தார் 'அனைத்து உரை கோப்புகளையும் காண்பி.'
ls *.txt

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

$பேஷ்fglobe_script.sh

கோப்பு குளோபிங்கை அணைக்க, பயன்படுத்தவும் -f விருப்பம்:

$பேஷ் -ffglobe_script.sh

இதேபோல், நீங்கள் அதை ஷெபாங் மற்றும் உடன் பயன்படுத்தலாம் அமை கட்டளை:

#! /பின்/பேஷ்
வெளியே எறிந்தார் 'அனைத்து உரை கோப்புகளையும் காண்பி.'
ls *.txt
அமை -f
வெளியே எறிந்தார் 'அனைத்து உரை கோப்புகளையும் காண்பி'
ls *.txt
அமை+எஃப்

இப்போது, ​​ஓடு பேஷ் fglobe_script.sh:

உடன் இணைக்கப்பட்டுள்ள பகுதி set -f/set +f வைல்ட்கார்டு எழுத்துகளுடன் கட்டளைகளை விருப்பங்கள் செயல்படுத்தவில்லை.

8. ஷெல் ஸ்கிரிப்டை பிழைத்திருத்த விருப்பங்களை எவ்வாறு இணைப்பது:

மேலே குறிப்பிட்டுள்ள பிழைத்திருத்த நுட்பங்களில் ஒரே ஒரு விருப்பத்தை மட்டுமே பயன்படுத்துகிறோம், ஆனால் சிறந்த புரிதலுக்காக பல்வேறு விருப்பங்களை இணைக்கலாம். செயல்படுத்துவோம் -எக்ஸ் மற்றும் -வி விருப்பங்கள் sum_script.sh கையால் எழுதப்பட்ட தாள். நான் பயன்படுத்துகிறேன் sum_script.sh கையால் எழுதப்பட்ட தாள்.

#! /பின்/பேஷ்
வெளியே எறிந்தார் 'முதல் எண்ணை உள்ளிடவும்'
படிஇலக்கம் 1
வெளியே எறிந்தார் இரண்டாவது எண்ணை உள்ளிடவும்
படிஎண் 2
தொகை= $[எண் 1 + எண் 2]
வெளியே எறிந்தார் தொகை ஆகும்$ தொகை'

இப்போது இயக்கவும்:

$பேஷ் -xvsum_script.sh

இரண்டும் -எக்ஸ் மற்றும் -வி வெளியீடு படத்தில் காட்டப்பட்டுள்ளபடி, வெளியீடுகள் இணைக்கப்படுகின்றன. இதேபோல், நாமும் இணைக்கலாம் -உ பிழை கண்டறிதலுக்கான verbose -v உடன் விருப்பம். நான் மாற்றுகிறேன் இலக்கம் 1 உடன் மாறி ஒன்றின் மீது ஸ்கிரிப்டின் ஆறாவது வரியில்:

#! /பின்/பேஷ்
இருக்கிறது$ எண் 2மற்றும்தொகைஇருக்கிறது$ தொகைபிழை
வெளியே எறிந்தேன் '
முதல் எண்ணை உள்ளிடவும்'
எண் 1 ஐ வாசிக்கவும்
வெளியே எறிந்தேன் '
இரண்டாவது எண்ணை உள்ளிடவும்'
எண் 2 படிக்கவும்
தொகை = $ [எண் + எண் 2]
வெளியே எறிந்தேன் '
திதொகைஇருக்கிறது$ தொகை'

வெளியீட்டைப் பார்க்க, கீழே குறிப்பிடப்பட்டுள்ள கட்டளையை இயக்கவும்:

$பேஷ் -இவ்sum_script.sh

9. பிழைத்திருத்த அறிக்கையை ஒரு கோப்பில் திருப்பிவிடுவது எப்படி:

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

#! /பின்/பேஷ்
நிறைவேற்று 5>dubug_report.log
BASH_XTRACED='5'
பிஎஸ் 4='$ LINENO--'
வெளியே எறிந்தார் எண் 1 ஐ உள்ளிடவும்
படிஇலக்கம் 1
வெளியே எறிந்தார் எண் 2 ஐ உள்ளிடவும்
படிஎண் 2
என்றால் [ '$ எண்' -ஜிடி '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 ஐ விட அதிகம்'
எலிஃப் [ '$ எண் 1' -எக்யூ '$ எண் 2' ]
பிறகு
வெளியே எறிந்தார் 'எண் 1 எண் 2 க்கு சமம்'
வேறு
வெளியே எறிந்தார் 'எண் 2 எண் 1 ஐ விட அதிகம்'
இரு

குறியீட்டின் இரண்டாவது வரியில், நாம் வெளியீட்டை a க்கு திருப்பிவிடுவதைக் காணலாம் debug_report.log கோப்பைப் பயன்படுத்தி நிறைவேற்று கோப்பு விளக்கம் 5 (FD5) உடன் கட்டளை.

exec 5> debug_report.log: தி நிறைவேற்று கட்டளை ஷெல்லில் நடக்கும் அனைத்தையும் ஒரு கோப்பிற்கு திருப்பிவிடுகிறது debug_report.log.

BASH_XTRACEFD = 5: அது ஒரு குறிப்பிட்ட பேஷ் மாறி மற்றும் வேறு எந்த ஷெல்லிலும் பயன்படுத்த முடியாது. இது ஒரு சரியான கோப்பு விளக்கத்தை ஒதுக்க வேண்டும், மற்றும் பாஷ் பிரித்தெடுக்கப்பட்ட வெளியீட்டை எழுதுவார் debug_report.log.

PS4 = '$ LINENO- ': இது எக்ஸ்ட்ரேஸ் பயன்முறையைப் பயன்படுத்தி பிழைத்திருத்தத்தின் போது வரி எண்ணை அச்சிடப் பயன்படுத்தப்படும் ஒரு பாஷ் மாறி ஆகும். பிஎஸ் 4 இன் இயல்புநிலை மதிப்பு + அடையாளம்

மேலே உள்ள ஸ்கிரிப்ட் ஒரு பதிவு கோப்பை உருவாக்குகிறது debug_report.log, அதைப் படிக்க, பயன்படுத்தவும் பூனை கட்டளை:

முடிவுரை:

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

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