Anumang programa ay kailangang malaya sa mga error bago maabot ang mga mamimili. Sinusubukan ng mga developer ng software ang kanilang makakaya upang gawing walang bug ang mga programa ng software. Ngunit mahirap gawin ang isang code na walang kamali-mali kapag mayroong libu-libong mga linya. Ang pag-debug ay isang patuloy na proseso; nakakatulong ito sa agad na pagtuklas ng mga error, pagtitipon ng mahalagang impormasyon tungkol sa code, at pag-aalis ng mga kalabisan na mga chunks ng code.
Ang lahat ng mga wika ng programa ay mayroong ilang mga karaniwang at kakaibang mga diskarte upang makahanap ng mga bug. Halimbawa, ang mga programa sa pag-debug ay maaaring magamit upang matanggal nang mabilis ang mga error. Samantalang ang shell scripting ay walang anumang partikular na tool upang i-debug ang code. Ang pagsulat na ito ay tungkol sa pagtalakay sa iba't ibang mga diskarte sa pag-debug na maaaring magamit upang gawing walang error ang bash script. Bago kami sumisid sa mga pamamaraan, magkaroon tayo ng pangunahing pag-unawa sa mga shell at shell scripting:
Ano ang shell sa Linux?
Kapag na-boot mo ang iyong computer, nakakakuha ang kernel ng impormasyon tungkol sa nakalakip na hardware at pinapayagan ang iba pang mga nakakabit na sangkap na makipag-ugnay. Bukod sa na, namamahala ito ng memorya, CPU at kinikilala ang anumang bagong paligid. Sa kabuuan, ang isang kernel ay ang gulugod ng anumang operating system. Ngunit naisip mo ba na direktang makipag-ugnay sa kernel, utusan ito upang magsagawa ng isang tukoy na gawain? Maaari bang gawin ito? Talagang! Sa tulong ng isang shell, isang programa sa computer na may isang interactive interface, kahit sino ay maaaring patakbuhin ang kernel. Pinapayagan ng shell ang mga tao na makipag-ugnay sa kernel at turuan ito na magsagawa ng anumang gawain.
Sa Unix, mayroong dalawang pangunahing mga shell Bourne shell at C shell . Parehong ng mga uri ay may kanilang mga subcategory. Iba't ibang uri ng mga Bourne shell ay Korn shell (ksh), Almquist shell (abo), Bourne ulit na shell (bash), at Z shell (zsh) . Sa parehong oras, ang C shell ay may sariling mga subcategoryang tulad C shell (csh) at TENEX C na shell (tcsh) . Tulad ng nabanggit sa itaas, sa lahat ng mga shell, Bash (Bourne muli shell) ay ang pinaka malawak na ginagamit na shell at lumabas sa kahon sa maraming mga pamamahagi ng Linux dahil sa kahusayan at kabaitan ng gumagamit.
Ang Bash ay ang default na shell ng maraming pamamahagi ng Linux at malawak na ginagamit ng milyun-milyong mga gumagamit ng Linux. Napakakaiba at maimpluwensyang maaari nitong maisagawa ang bawat gawain na karaniwang ginagawa mo sa mga application na nakabatay sa GUI. Maaari kang mag-edit ng mga file, pamahalaan ang mga file, tingnan ang mga larawan, makinig ng musika, maglaro ng mga video, at marami pa.
Ano ang isang Shell Script:
Tulad ng natutunan natin ang pangunahing ideya ng shell, ngayon ay lumipat tayo sa shell scripting. Ang shell script ay isang programa sa computer na nagsasagawa ng maraming mga utos sa isang shell na kumikilos bilang isang interpreter upang maisagawa ang isang tukoy na pagpapaandar. Tulad ng tinalakay sa itaas na, mayroong 2 partikular na uri ng mga shell. Gayunpaman, ang gabay na ito ay nakatuon sa Bourne Again shell (Bash).
Kaya ano ang isang bash script? Sa Linux, ang lahat ng mga utos na bash ay nakaimbak sa / usr / bin at / basurahan mga folder. Halimbawa, tuwing nagpapatakbo ka ng isang utos, bash paghahanap kung mayroon ito sa direktoryo o hindi. Ang utos ay naisakatuparan kung mahahanap ito sa mga direktoryo kung hindi ay nagbibigay ng isang error.
Paano ang tungkol sa pagsasagawa ng isang gawain na nangangailangan ng maraming mga utos upang tumakbo sa terminal? Sa tukoy na sitwasyong ito, makakatulong sa iyo ang bash scripting. Ang Bash scripting ay isang uri ng shell scripting na nagbibigay-daan sa iyo upang gumawa ng mga programa upang magpatakbo ng maraming mga bash command upang maisagawa ang isang tukoy na gawain.
Ano ang mga bug sa bash scripting:
Habang nagtatrabaho sa bash scripting o sa anumang iba pang mga wika sa programa, nakakaranas ka ng maraming mga error. Ang isang bug ay isang error o isang pagkakamali sa programa na maaaring maging sanhi ng maling pag-uugali ng programa.
Ang bawat wika ng programa ay may sariling pamamaraan upang makahanap ng mga bug; katulad din, ang bash ay mayroon ding maraming mga pagpipilian sa built-in upang i-debug ang isang programa ng terminal.
Ang pamamahala ng mga error at pag-debug ng isang programa ay hindi mas mababa sa isang abala. Ito ay isang matagal na trabaho at maaaring lumala kung hindi mo alam ang tamang mga tool upang mai-debug ang iyong programa. Ang pagsulat na ito ay isang kumpletong gabay tungkol sa pag-debug ng mga bash-script upang gawing walang error ang iyong script. Magsimula tayo:
Paano i-debug ang isang bash script:
Kapag nagtatrabaho ka sa mga malalaking proyekto sa pagprogram, nakakaranas ka ng maraming mga error o bug. Kung minsan ay kumplikado ang pag-debug ng isang programa. Karaniwang gumagamit ang mga programmer ng mga tool sa pag-debug, at maraming mga editor ng code ang tumutulong din sa paghahanap ng bug sa pamamagitan ng pag-highlight ng syntax.
Mayroong iba't ibang mga tool sa Linux upang mai-debug ang mga code, halimbawa, GNU Debugger aka gdb. Ang mga tool tulad ng GDB ay kapaki-pakinabang para sa mga wika ng pag-program na umaipon sa mga binary. Dahil ang bash ay isang simpleng naisalin na wika, hindi na kailangan ng mga mabibigat na tool upang mai-debug ito.
Mayroong iba't ibang mga tradisyunal na diskarte upang i-debug ang isang bash scripting code, at isa sa mga ito ay pagdaragdag Mga Pahayag. Ang mga assertion ay mga kundisyon na idinagdag sa mga programa upang suriin ang mga tukoy na kundisyon at ipatupad ang programa nang naaayon. Ito ay isang nagtatanggol na pamamaraan na makakatulong sa paghahanap ng mga bug at pagsubok din. Maaari kang makahanap ng marami mga kasangkapan na tumutulong sa pagdaragdag ng mga assertions sa bash script.
Sa gayon, ang pagdaragdag ng mga assertion ay isa sa mga dating tradisyonal na diskarte. Mayroong mga hanay ng mga watawat / pagpipilian na magagamit sa bash upang i-debug ang isang bash script. Ang mga pagpipiliang ito ay maaaring maidagdag kasama ang shebang sa mga script o idinagdag habang isinasagawa ang programa sa terminal. Ang mga paksang tatanggapin namin ay nakalista sa ibaba:
- Paano i-debug ang bash script sa pamamagitan ng pagpapagana verbose -v pagpipilian
- Paano i-debug ang bash script gamit xtrace -x pagpipilian
- Paano i-debug ang bash script gamit noexec -n pagpipilian
- Paano makikilala ang mga unset variable habang debugging ang bash script
- Paano i-debug ang tiyak na bahagi ng bash script
- Paano i-debug ang isang bash script gamit ang bitag utos
- Paano i-debug ang isang bash script sa pamamagitan ng pag-aalis file globbing gamit ang -f pagpipilian
- Paano pagsamahin mga pagpipilian sa pag-debug upang i-debug ang isang shell script
- Paano i-redirect ang ulat ng debug sa isang file
Kaya't suriin natin ang iba't ibang mga diskarte sa bash upang mai-debug ang isang bash script:
1. Paano i-debug ang bash script sa pamamagitan ng pagpapagana ng opsyon na verbose -v:
Ang isa sa pinakamadaling diskarte upang i-debug ang bash script ay ang paggamit ng -v pagpipilian, na kilala rin bilang verbose. Maaaring idagdag ang pagpipilian sa shebang o malinaw na ilagay sa pangalan ng file ng script habang isinasagawa ito. Ang opsyong verbose ay papatupad at mai-print ang bawat linya ng code bilang proseso ng interpreter. Unawain natin ito sa isang halimbawa ng bash script:
#! / basahan / bashitinapon 'Ipasok ang Numero1'
basahinbilang1
itinapon 'Ipasok ang Numero2'
basahinbilang2
kung [ '$ number1' -gt '$ number2' ]
tapos
itinapon 'Ang numero1 ay mas malaki kaysa sa Number2'
elif [ '$ number1' -eq '$ number2' ]
tapos
itinapon 'Number1 ay katumbas ng Number2'
iba pa
itinapon 'Ang number2 ay mas malaki kaysa sa Number1'
maging
Ang code sa itaas ay nakakakuha ng dalawang numero mula sa gumagamit at pagkatapos ay gumaganap ng ilang mga kondisyong pahayag upang suriin kung ang bilang ay mas makabuluhan, mas mababa, o katumbas ng iba pang ipinasok na numero. Kahit na ang anumang text editor ay maaaring magamit para sa bash scripting, gumagamit ako ng Vim editor. Ang Vim ay isang malakas, mayaman sa tampok na editor na nagha-highlight sa syntax ng bash script at binabawasan ang mga pagkakataon ng mga error sa syntax. Kung wala kang Vim editor, kunin ito sa pamamagitan ng pagpapatakbo ng utos na nabanggit sa ibaba:
$sudoapti-install dumating akoLumikha ng isang bash script file gamit ang:
$dumating akob_script.shKung bago ka sa Vim editor, inirerekumenda kong malaman mo kung paano gamitin ang vim editor bago magpatuloy.
Ngayon, bumalik sa script, ipatupad ang script sa pamamagitan ng paggamit -v pagpipilian:
$bash -vb_script.sh 
Makikita sa output sa itaas na ang bawat linya ng script ay nakalimbag sa terminal habang pinoproseso ng interpreter. Tandaan na hihinto ang script sa pagkuha ng input mula sa gumagamit at pagkatapos ay iproseso ang susunod na linya ng script. Tulad ng tinalakay sa itaas na ang -v ang pagpipilian ay maaaring mailagay pagkatapos ng shebang tulad ng ipinakita sa mga sumusunod:
#! / basahan / bash -v 
Katulad nito, ang flag ng verbose ay maaari ring idagdag sa susunod na linya ng shebang gamit ang itakda utos:
#! / basahan / bashitakda -v
Anumang mga pamamaraan na tinalakay sa itaas ay maaaring paganahin ang verbose.
2 Paano i-debug ang bash script gamit ang xtrace -x na pagpipilian:
Ang trace ng pagpapatupad, kilala rin bilang xtrace ay isang matalino at kapaki-pakinabang na pagpipilian sa pag-debug, lalo na upang masubaybayan ang mga lohikal na error. Ang mga lohikal na error ay karaniwang nauugnay sa mga variable at utos. Upang suriin ang estado ng variable sa panahon ng pagpapatupad ng script, ginagamit namin ang -x pagpipilian Ngayon muli, patakbuhin ang b_script.sh file kasama ang -x bandila:
$bash -xb_script.sh 
Ang output ay malinaw na ipinapakita ang halaga ng bawat variable sa panahon ng proseso ng pagpapatupad. Muli, ang -x maaaring magamit sa tabi ng shebang at pagkatapos ng shebang line gamit ang itinakdang utos. Inilalagay ng xtrace ang + sign sa bawat linya ng script.
3 Paano i-debug ang bash script gamit ang noexec -n na pagpipilian:
Ang mga error sa syntax ay isa sa mga pangunahing sanhi ng mga bug. Upang syntactically i-debug ang bash script, ginagamit namin noexec (walang pagpapatupad) mode. Ang opsyong ginamit para sa noexec mode ay -n Ipapakita lamang nito ang mga error sa syntax ng code sa halip na ipatupad ito. Isang mas ligtas na diskarte sa pag-debug ng code. Isagawa natin b_script.sh muli kasama ang -n pagpipilian:
$bash -nb_script.shWalang pagpapatupad ng code kung walang error sa syntax. Ngayon, baguhin natin ang aming code:
#! / basahan / bashitinapon 'Ipasok ang Numero1'
basahinbilang1
itinapon 'Ipasok ang Numero2'
basahinbilang2
kung [ '$ number1' -gt '$ number2' ]
tapos
itinapon 'Ang numero1 ay mas malaki kaysa sa Number2'
elif [ '$ number1' -eq '$ number2' ]
#tapos
itinapon 'Number1 ay katumbas ng Number2'
iba pa
itinapon 'Ang number2 ay mas malaki kaysa sa Number1'
maging
Nagcocomment ako tapos pagkatapos elif . Ngayon, na may -n na pagpapatupad b_script.sh script:
$bash -nb_script.sh 
Tulad ng inaasahan, malinaw na nakilala nito ang error at ipinakita ito sa terminal.
4 Paano makilala ang mga hindi naitakda na variable habang nai-debug ang bash script:
Ang paggawa ng isang typo habang nagsusulat ng isang code ay karaniwan. Kadalasan, nagkakamali ka ng pag-type ng variable, na hindi pinapayagan ang pagpapatupad ng code. Upang makilala ang gayong error, ginagamit namin ang -u pagpipilian Baguhin ulit ang code:
#! / basahan / bashitinapon 'Ipasok ang Numero1'
basahinnumero1
itinapon 'Ipasok ang Numero2'
basahinbilang2
kung [ '$ num1' -gt '$ number2' ]
tapos
itinapon 'Ang numero1 ay mas malaki kaysa sa Number2'
elif [ '$ number1' -eq '$ number2' ]
tapos
itinapon 'Number1 ay katumbas ng Number2'
iba pa
itinapon 'Ang number2 ay mas malaki kaysa sa Number1'
maging
Sa una kung kondisyon na pahayag, pinalitan ko ng pangalan ang bilang1 variable sa num1 . Ngayon num1 ay isang unset variable. Patakbuhin ngayon ang script:
$bash -ub_script.sh 
Ang output ay nakilala at malinaw na ipinapakita ang pangalan ng isang hindi naka-set na variable.
5. Paano i-debug ang tiyak na bahagi ng bash script:
Pinoproseso ng xtrace mode ang bawat linya ng code at nagbibigay ng output. Gayunpaman, ang paghanap ng mga error sa isang malaking code ay magtatagal kung nalalaman na natin kung aling bahagi ang maaaring maging sanhi ng error. Sa kabutihang palad, pinapayagan ka rin ng xtrace na i-debug ang isang tukoy na bahagi ng code, na maaaring magawa gamit ang itakda utos Lugar itakda -x sa simula ng bahagi na kailangang i-debug at pagkatapos itakda + x sa dulo. Halimbawa, nais kong i-debug ang mga kondisyong pahayag ng b_script.sh , kaya isasara ko ang lahat ng mga kondisyong pahayag sa itakda -x at itakda + x mga pagpipilian tulad ng ipinakita sa code sa ibaba:
#! / basahan / bashitinapon 'Ipasok ang Numero1'
basahinnumero1
itinapon 'Ipasok ang Numero2'
basahinbilang2
itakda -x
kung [ '$ number' -gt '$ number2' ]
tapos
itinapon 'Ang numero1 ay mas malaki kaysa sa Number2'
elif [ '$ number1' -eq '$ number2' ]
tapos
itinapon 'Number1 ay katumbas ng Number2'
iba pa
itinapon 'Ang number2 ay mas malaki kaysa sa Number1'
maging
itakda+ x
Ngayon, patakbuhin ang script gamit ang bash b_script.sh .
Ang output ay naka-debug lamang kung ang mga kundisyon tulad ng tinukoy.
6. Paano i-debug ang isang bash script gamit ang snap command:
Kung ang iyong iskrip ay kumplikado, kung gayon mayroong higit pang mga masalimuot na diskarte pati na rin para sa pag-debug. Isa sa mga ito ay ang bitag utos Ang bitag nahuhuli ng utos ang mga signal at nagpapatupad ng isang utos kapag nangyari ang isang tukoy na sitwasyon. Ang utos ay maaaring isang senyas o isang pagpapaandar. Lumikha ako ng isa pang script sa pamamagitan ng pangalan ng sum_script.sh :
#! / basahan / bashbitag 'echo' Line $ {LINENO}: Ang unang numero ay $ number1, Ang pangalawang numero ay $ number2 at ang sum ay $ sum 'DEBUG
itinapon 'Ipasok ang unang numero'
basahinnumero1
itinapon 'Ipasok ang pangalawang numero'
basahinbilang2
kabuuan= $[numero1 + numero2]
itinapon 'ang kabuuan ay$ sum'
Ang bitag utos sa DEBUG ipakita ang signal ang katayuan ng mga variable bilang1 , bilang2 at kabuuan pagkatapos ng pagpapatupad ng bawat linya tulad ng ipinakita sa sumusunod na imahe ng output:
Ang mga dilaw na bloke ay mga blangko na puwang dahil ang gumagamit ay hindi pa nagpasok ng walang input; mapupunan ang mga puwang na ito sa pagpasok ng gumagamit ng mga halaga. Ang pamamaraang ito ay kapaki-pakinabang din sa pag-debug ng mga script ng bash.
7. Paano i-debug ang isang bash script sa pamamagitan ng pag-aalis ng file globbing gamit ang pagpipilian na -f:
Ang file globbing ay isang proseso ng paghanap ng mga file na may mga wildcard character, ibig sabihin, * at ? . Sa maraming sitwasyon, hindi mo kailangang palawakin ang mga file habang nagde-debug. Sa mga ganitong kaso, maaari mong harangan ang file globbing gamit ang -f pagpipilian Unawain natin ito sa isang script fglobe_script.sh :
#! / basahan / bashitinapon 'Ipakita ang lahat ng mga text file.'
ls *.txt
Ipapakita ng code sa itaas ang lahat ng mga file ng teksto sa kasalukuyang direktoryo, isagawa:
$bashfglobe_script.sh 
Upang i-off ang file globbing, gamitin ang -f pagpipilian:
$bash -ffglobe_script.sh 
Katulad nito, maaari mo itong magamit sa shebang at sa itakda utos din:
#! / basahan / bashitinapon 'Ipakita ang lahat ng mga text file.'
ls *.txt
itakda -f
itinapon 'Ipakita ang lahat ng mga text file'
ls *.txt
itakda+ f
Ngayon, tumakbo bash fglobe_script.sh:
Ang bahaging nakapaloob itakda -f / set + f ang mga pagpipilian ay hindi naproseso ang mga utos na may mga character na wildcard.
8. Paano pagsamahin ang mga pagpipilian sa pag-debug upang i-debug ang shell script:
Gumagamit lamang kami ng isang pagpipilian sa nabanggit na mga diskarteng pag-debug sa itaas, ngunit maaari naming pagsamahin ang iba't ibang mga pagpipilian para sa mas mahusay na pagkaunawa. Ipatupad natin -x at -v mga pagpipilian sa sum_script.sh iskrip. Ginagamit ko ang sum_script.sh iskrip.
#! / basahan / bashitinapon 'Ipasok ang unang numero'
basahinnumero1
itinapon 'Ipasok ang pangalawang numero'
basahinbilang2
kabuuan= $[numero1 + numero2]
itinapon 'ang kabuuan ay$ sum'
Magpatupad ngayon:
$bash -xvsum_script.sh 
Pareho -x at -v ang mga output ay pinagsama, tulad ng ipinapakita sa imahe ng output. Katulad nito, maaari din nating pagsamahin ang -u pagpipilian na may verbose -v para sa pagtuklas ng error. Papalitan ko ang bilang1 variable na may sa isa sa ikaanim na linya ng script:
#! / basahan / bashay$ number2atkabuuanay$ sum'' DEBUG
itinapon 'Ipasok ang unang numero'
basahin ang bilang1
itinapon 'Ipasok ang pangalawang numero'
basahin ang bilang2
kabuuan = $ [num + number2]
itinapon 'angkabuuanay$ sum'
Upang matingnan ang output, patakbuhin ang utos na nabanggit sa ibaba:
$bash -uvsum_script.sh 
9. Paano mag-redirect ng ulat ng pag-debug sa isang file:
Ang pag-save ng isang ulat ng pag-debug ng isang bash script sa isang file ay maaaring maging madaling gamiting sa maraming mga sitwasyon. Medyo nakakalito dahil upang mai-redirect ang pag-ulat ng debug sa isang file; gumagamit kami ng ilang mga espesyal na variable. Ipatupad natin ito sa b_script.sh code:
#! / basahan / bashexec 5>dubug_report.log
BASH_XTRACED='5'
PS4='$ LINENO--'
itinapon 'Ipasok ang Numero1'
basahinbilang1
itinapon 'Ipasok ang Numero2'
basahinbilang2
kung [ '$ number' -gt '$ number2' ]
tapos
itinapon 'Ang numero1 ay mas malaki kaysa sa Number2'
elif [ '$ number1' -eq '$ number2' ]
tapos
itinapon 'Number1 ay katumbas ng Number2'
iba pa
itinapon 'Ang number2 ay mas malaki kaysa sa Number1'
maging
Sa pangalawang linya ng code, makikita na dinididirekta namin ang output sa a debug_report.log file gamit ang exec utos gamit ang deskriptor ng file 5 (FD5).
exec 5> debug_report.log: Ang exec Ang utos ay nagre-redirect sa lahat ng nangyayari sa shell sa isang file debug_report.log.
BASH_XTRACEFD = 5: Ito ay isang partikular na variable ng bash at hindi maaaring gamitin sa iba pang mga shell. Kailangan itong italaga ng isang wastong tagapaglarawan ng file, at susulatin ng bash ang nakuha na output sa debug_report.log.
PS4 = ’$ LINENO– ‘: Ito rin ay isang bash variable na ginamit upang i-print ang numero ng linya habang ang pag-debug gamit ang xtrace mode. Ang default na halaga ng PS4 ay ang + tanda
Ang script sa itaas ay bumubuo ng isang log file na tinawag debug_report.log, upang basahin ito, gamitin ang pusa utos:
Konklusyon:
Ang isang code na puno ng mga bug ay maaaring makaapekto sa pagganap ng programa at nakakapinsala din sa hardware. Napakahalaga ng pag-debug para sa bawat programa dahil ginagawa nitong mas mahusay ang programa. Ang paghanap ng mayroon at mga potensyal na pagkakamali sa panahon ng pagbuo ng isang programa ay maaaring maiwasan ang iyong programa na kumilos nang hindi inaasahan. Ang mga malalaking code ay karaniwang nangangailangan ng aktibong pag-debug, pagpapahusay ng pagiging epektibo ng code sa pamamagitan ng pag-aalis ng paggamit ng mga chunk ng code.
Maraming mga wika ng wika at kapaligiran ay may kani-kanilang kasamang mga debugger. Sa bash scripting, maaaring ipatupad ang iba't ibang mga diskarte upang mai-debug ang script. Ang gabay na ito ay lubusang nakatuon sa lahat ng mga pamamaraan na maaaring magamit upang makahanap ng mga bug sa mga script ng bash. Kaya't tuwing sa tingin mo na ang iyong bash script ay hindi kumikilos tulad ng inaasahan, gumamit ng alinman sa mga diskarteng nabanggit sa itaas, ngunit ang xtrace mode (-x) ay lubos na kapaki-pakinabang sa karamihan ng mga kaso.