Hur felsöker jag ett bash -skript?

How Debug Bash Script




Alla program måste vara fria från fel innan de når konsumenterna. Programutvecklare gör sitt bästa för att göra programmen buggfria. Men det är svårt att göra en kod felfri när det finns tusentals rader. Felsökning är en pågående process; det hjälper till att omedelbart upptäcka fel, samla värdefull information om kod och eliminera överflödiga kodbitar.

Alla programmeringsspråk har några vanliga och få distinkta metoder för att hitta buggar. Till exempel kan felsökningsprogram användas för att snabbt ta bort fel. Medan skalskript inte har något särskilt verktyg för att felsöka koden. Denna skrivning handlar om att diskutera olika felsökningstekniker som kan användas för att göra bash-skriptet felfritt. Innan vi dyker in i metoderna, låt oss ha en grundläggande förståelse för skal och skalskript:







Vad är skalet i Linux?

När du startar upp datorn får kärnan information om den anslutna hårdvaran och låter andra anslutna komponenter interagera. Bortsett från det hanterar det minne, CPU och känner igen någon ny kringutrustning. Sammantaget är en kärna ryggraden i alla operativsystem. Men har du någonsin tänkt att interagera direkt med kärnan, beordra den att utföra en specifik uppgift? Är det ens praktiskt möjligt att göra det? Absolut! Med hjälp av ett skal, ett datorprogram med ett interaktivt gränssnitt kan vem som helst styra kärnan. Skalet tillåter människor att interagera med kärnan och instruera den att utföra alla uppgifter.



I Unix finns det två huvudskal Bourne skal och C skal . Båda dessa typer har sina underkategorier. Olika typer av Bourne -skal är Kornskal (ksh), Almquistskal (aska), Bourne igen skal (bash), och Z skal (zsh) . Samtidigt har C -skalet sina egna underkategorier som C -skal (csh) och TENEX C skal (tcsh) . Som nämnts ovan, av alla skal, Bash (Bourne igen skal) är det mest använda skalet och kommer ur lådan i många Linux-distributioner på grund av dess effektivitet och användarvänlighet.



Bash är standardskal för många Linux -distributioner och används i stor utsträckning av miljontals Linux -användare. Det är så mångsidigt och inflytelserikt att det kan utföra varje uppgift du vanligtvis utför i GUI-baserade applikationer. Du kan redigera filer, hantera filer, visa foton, lyssna på musik, spela upp videor och mycket mer.





Vad är ett Shell Script:

Eftersom vi har lärt oss grundtanken med skal, låt oss nu gå mot skalskript. Skalskriptet är ett datorprogram som kör flera kommandon i ett skal som fungerar som tolk för att utföra en specifik funktion. Som diskuterats ovan finns det två särskilda typer av skal. Denna guide fokuserar dock på Bourne Again -skalet (Bash).
Så vad är ett bash -skript? I Linux lagras alla bash -kommandon i /usr /bin och /bin mappar. Till exempel, när du kör ett kommando, söker bash om det finns i katalogen eller inte. Kommandot körs om det finns i katalogerna annars ger ett fel.

Vad sägs om att utföra en uppgift som behöver flera kommandon för att köra i terminalen? I denna specifika situation kan bash scripting hjälpa dig. Bash -skript är en form av skalskript som låter dig skapa program för att köra flera bash -kommandon för att utföra en specifik uppgift.



Vad är buggar i bash scripting:

När du arbetar med bash scripting eller med andra programmeringsspråk stöter du på många fel. Ett fel är ett fel eller ett fel i programmet som kan få programmet att fungera fel.

Varje programmeringsspråk har sin egen procedur för att hitta buggar; på samma sätt har bash också många inbyggda alternativ för att felsöka ett terminalprogram.

Hantera fel och felsöka ett program är inte mindre än krångel. Det är ett tidskrävande jobb och kan förvärras om du inte är medveten om rätt verktyg för att felsöka ditt program. Denna skrivning är en komplett guide om felsökning av bash-skript för att göra ditt skript felfritt. Så låt oss börja:

Så här felsöker du ett bash -skript:

När du arbetar med stora programmeringsprojekt stöter du på många fel eller buggar. Det kan ibland vara komplicerat att felsöka ett program. Programmerare använder vanligtvis felsökningsverktyg, och många kodredigerare hjälper också till att hitta fel genom att markera syntaxen.

Det finns olika verktyg i Linux för att felsöka koder, till exempel GNU Debugger aka gdb. Verktyg som GDB är användbara för programmeringsspråk som sammanställs till binära filer. Eftersom bash är ett enkelt tolkat språk behövs det inga tunga verktyg för att felsöka det.

Det finns olika traditionella tekniker för att felsöka en bash -skriptkod, och en av dem lägger till Påståenden. Påståenden är villkor som läggs till i programmen för att kontrollera specifika villkor och köra programmet i enlighet därmed. Det är en defensiv teknik som också hjälper till att hitta buggar och testa. Du kan hitta många verktyg som hjälper till att lägga till påståenden i bash -skript.

Att lägga till påståenden är en av de gamla traditionella teknikerna. Det finns uppsättningar flaggor/alternativ tillgängliga i bash för att felsöka ett bash -skript. Dessa alternativ kan läggas till tillsammans med shebang i skripten eller läggas till medan programmet körs i terminalen. De ämnen vi ska ta upp är listade nedan:

  1. Hur du felsöker bash -skript genom att aktivera ordagrant -v alternativ
  2. Hur man felsöker bash -skript med xtrace -x alternativ
  3. Hur man felsöker bash -skript med noexec -n alternativ
  4. Hur man identifierar oinställda variabler medan felsökning av bash -skript
  5. Hur felsöker jag specifik del av bash -skriptet
  6. Hur felsöker man ett bash -skript med fälla kommando
  7. Hur man felsöker ett bash -skript genom att eliminera fil globbing använda -f alternativ
  8. Hur kombinera felsökningsalternativ för att felsöka ett skalskript
  9. Hur omdirigera felsökningsrapport till en fil

Så låt oss kontrollera olika tekniker i bash för att felsöka ett bash -skript:

1. Hur du felsöker bash -skript genom att aktivera ett omfattande -v alternativ:

Ett av de enklaste sätten att felsöka bash -skriptet är att använda -v alternativ, även känt som utförligt. Alternativet kan läggas till med shebang eller uttryckligen sättas med skriptfilnamnet medan det körs. Det omfattande alternativet kommer att köra och skriva ut varje rad i koden som processen av tolken. Låt oss förstå det med ett bash script -exempel:

#! /bin/bash
kastade ut 'Ange nummer 1'
läsanummer ett
kastade ut 'Ange nummer 2'
läsanummer 2
om [ '$ nummer1' -gt '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är större än nummer 2'
elif [ '$ nummer1' -ekv '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är lika med nummer 2'
annan
kastade ut 'Nummer 2 är större än nummer 1'
vara

Ovanstående kod får två nummer från användaren och utför sedan några villkorliga uttalanden för att kontrollera om talet är mer signifikant, mindre eller lika med det andra inmatade numret. Även om vilken textredigerare som helst kan användas för bash scripting, använder jag Vim editor. Vim är en kraftfull, funktionsrik editor som belyser syntaxen för bash-skript och minskar risken för syntaxfel. Om du inte har Vim -editor, hämta det genom att köra kommandot som nämns nedan:

$sudobenägenInstallera jag kom

Skapa en bash -skriptfil med:

$jag komb_script.sh

Om du är ny på Vim editor, rekommenderar jag att du lär dig hur man använder vim -redigeraren innan fortsättning.

Nu, tillbaka till skriptet, kör skriptet med -v alternativ:

$våldsamt slag -vb_script.sh

Det kan ses i ovanstående utdata att varje rad i skriptet skrivs ut i terminalen när de behandlas av tolken. Observera att skriptet slutar ta in input från användaren och sedan bearbetar nästa rad i skriptet. Som diskuterats ovan att -v alternativet kan placeras efter shebang som visas i följande:

#! / bin / bash -v

På samma sätt kan den generösa flaggan också läggas till på nästa rad i shebang med hjälp av uppsättning kommando:

#! /bin/bash
uppsättning -v

Vilken som helst av metoderna som diskuteras ovan kan möjliggöra verbose.

2 Hur man felsöker bash -skript med alternativet xtrace -x:

Exekveringsspårning, även känd som xtrace är ett smart och användbart felsökningsalternativ, särskilt för att spåra logiska fel. Logiska fel är vanligtvis associerade med variabler och kommandon. För att kontrollera variabelns tillstånd under körningen av manuset använder vi -x alternativ. Nu igen, kör b_script.sh fil med -x flagga:

$våldsamt slag -xb_script.sh

Utdata visar uttryckligen värdet på varje variabel under körningsprocessen. Återigen, -x kan användas bredvid shebang och efter shebang -raden med kommandot set. Xtrace sätter + -tecknet med varje rad i skriptet.

3 Så här felsöker du bash -skript med alternativet noexec -n:

Syntaxfel är en av de främsta orsakerna till buggar. För att syntaktiskt felsöka bash -skriptet använder vi noexec (ingen körning) -läge. Alternativet som används för noexec -läge är -n. Den visar bara kodens syntaxfel istället för att köra den. Ett mycket säkrare sätt att felsöka koden. Låt oss verkställa b_script.sh igen med -n alternativ:

$våldsamt slag -nb_script.sh

Det kommer inte att utföras någon kod om det inte finns något syntaxfel. Låt oss nu ändra vår kod:

#! /bin/bash

kastade ut 'Ange nummer 1'
läsanummer ett
kastade ut 'Ange nummer 2'
läsanummer 2
om [ '$ nummer1' -gt '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är större än nummer 2'
elif [ '$ nummer1' -ekv '$ nummer2' ]
#sedan
kastade ut 'Nummer 1 är lika med nummer 2'
annan
kastade ut 'Nummer 2 är större än nummer 1'
vara

Jag kommenterar sedan efter elif . Nu, med -n execute b_script.sh manus:

$våldsamt slag -nb_script.sh

Som förväntat identifierade det tydligt felet och visade det i terminalen.

4 Hur man identifierar de inställda variablerna vid felsökning av bash -skript:

Det är vanligt att du skriver fel när du skriver en kod. Ofta skriver du fel en variabel som inte låter koden köras. För att identifiera ett sådant fel använder vi -u alternativ. Låt oss ändra koden igen:

#! /bin/bash
kastade ut 'Ange nummer 1'
läsanummer ett
kastade ut 'Ange nummer 2'
läsanummer 2
om [ '$ num1' -gt '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är större än nummer 2'
elif [ '$ nummer1' -ekv '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är lika med nummer 2'
annan
kastade ut 'Nummer 2 är större än nummer 1'
vara

I den första om villkorligt uttalande bytte jag namn på nummer ett variabel till num1 . Nu num1 är en icke inställd variabel. Kör nu skriptet:

$våldsamt slag -ub_script.sh

Utdata har identifierat och visar uttryckligen namnet på en icke inställd variabel.

5. Hur felsöker jag den specifika delen av bash -skriptet:

Xtrace -läget behandlar varje rad i koden och ger utdata. Att hitta fel i en stor kod skulle dock vara tidskrävande om vi redan vet vilken del som potentiellt kan orsaka felet. Lyckligtvis tillåter xtrace dig också att felsöka en specifik del av koden, som kan åstadkommas med uppsättning kommando. Plats set -x i början av den del som måste felsökas och sedan set +x i slutet. Till exempel vill jag felsöka villkorliga uttalanden av b_script.sh , så jag kommer att bifoga alla villkorliga uttalanden i set -x och set +x alternativ som visas i koden nedan:

#! /bin/bash
kastade ut 'Ange nummer 1'
läsanummer ett
kastade ut 'Ange nummer 2'
läsanummer 2
uppsättning -x
om [ '$ -nummer' -gt '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är större än nummer 2'
elif [ '$ nummer1' -ekv '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är lika med nummer 2'
annan
kastade ut 'Nummer 2 är större än nummer 1'
vara
uppsättning+ x

Kör nu skriptet med bash b_script.sh .

Utdata felsöker bara if -villkoren enligt specifikationen.

6. Så här felsöker du ett bash -skript med kommandot trap:

Om ditt manus är komplicerat finns det också mer detaljerade tekniker för felsökning. En av dem är fälla kommando. De fälla kommando fångar upp signalerna och utför ett kommando när en specifik situation uppstår. Kommandot kan vara en signal eller en funktion. Jag har skapat ett annat skript med namnet sum_script.sh :

#! /bin/bash
fälla 'echo' Rad $ {LINENO}: Första talet är $ nummer1, Andra talet är $ nummer2 och summan är $ sum ''DEBUG
kastade ut 'Ange första nummer'
läsanummer ett
kastade ut 'Ange andra nummer'
läsanummer 2
belopp= $[nummer1 + nummer2]
kastade ut 'summan är$ summa'

De fälla kommando med DEBUG signal visar status för variablerna nummer ett , nummer 2 och belopp efter utförandet av varje rad som visas i följande utdata:

De gula blocken är tomma mellanslag eftersom användaren ännu inte har angett någon inmatning; dessa utrymmen fylls när användaren anger värden. Denna metod är också ganska användbar vid felsökning av bash -skript.

7. Så här felsöker du ett bash -skript genom att eliminera filglobning med alternativet -f:

Filglobning är en process för att hitta filer med jokertecken, dvs. * och ? . I många situationer behöver du inte expandera filer när du felsöker. I sådana fall kan du blockera filen globbing med -f alternativ. Låt oss förstå det med ett manus fglobe_script.sh :

#! /bin/bash
kastade ut 'Visa alla textfiler.'
ls *.Text

Ovanstående kod visar alla textfiler i den aktuella katalogen, kör:

$våldsamt slagfglobe_script.sh

För att stänga av filglobning, använd -f alternativ:

$våldsamt slag -ffglobe_script.sh

På samma sätt kan du använda den med shebang och med uppsättning kommando också:

#! /bin/bash
kastade ut 'Visa alla textfiler.'
ls *.Text
uppsättning -f
kastade ut 'Visa alla textfiler'
ls *.Text
uppsättning+f

Kör nu bash fglobe_script.sh:

Den del som bifogas set -f/set +f alternativ behandlade inte kommandon med jokertecken.

8. Så här kombinerar du felsökningsalternativ med felsökningsskript:

Vi använder bara ett alternativ i ovan nämnda felsökningsteknik, men vi kan kombinera olika alternativ för bättre förståelse. Låt oss genomföra -x och -v alternativ till sum_script.sh manus. Jag använder sum_script.sh manus.

#! /bin/bash
kastade ut 'Ange första nummer'
läsanummer ett
kastade ut 'Ange andra nummer'
läsanummer 2
belopp= $[nummer1 + nummer2]
kastade ut 'summan är$ summa'

Utför nu:

$våldsamt slag -xvsum_script.sh

Både -x och -v utgångar kombineras, som visas i utdatabilden. På samma sätt kan vi också kombinera -u alternativ med omfattande -v för feldetektering. Jag byter ut nummer ett variabel med på ett på manusets sjätte rad:

#! /bin/bash
är$ nummer2ochbeloppär$ summa'' DEBUG
kastade ut '
Ange första nummer'
läs nummer 1
kastade ut '
Ange det andra numret'
läs nummer 2
summa = $ [num + nummer2]
kastade ut '
debeloppär$ summa'

Kör kommandot nedan för att se utdata:

$våldsamt slag -uvsum_script.sh

9. Så här omdirigerar du felsökningsrapport till en fil:

Att spara en felsökningsrapport för ett bash -skript i en fil kan vara praktiskt i många situationer. Det är lite knepigt för att omdirigera felsökningsrapport till en fil; vi använder några speciella variabler. Låt oss implementera det på b_script.sh koda:

#! /bin/bash
exec 5>dubug_report.log
BASH_XTRACED='5'
PS4='$ LINENO--'
kastade ut 'Ange nummer 1'
läsanummer ett
kastade ut 'Ange nummer 2'
läsanummer 2
om [ '$ -nummer' -gt '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är större än nummer 2'
elif [ '$ nummer1' -ekv '$ nummer2' ]
sedan
kastade ut 'Nummer 1 är lika med nummer 2'
annan
kastade ut 'Nummer 2 är större än nummer 1'
vara

På den andra raden i koden kan man se att vi omdirigerar utmatningen till a debug_report.log fil med exec kommando med filbeskrivning 5 (FD5).

exec 5> debug_report.log: De exec kommando omdirigerar allt som händer i skalet till en fil debug_report.log.

BASH_XTRACEFD = 5: Det är en särskild bash -variabel och kan inte användas i något annat skal. Den måste tilldelas en giltig filbeskrivning, och bash skriver den extraherade utdata till debug_report.log.

PS4 = ’$ LINENO– ': Det är också en bash -variabel som används för att skriva ut radnumret vid felsökning med xtrace -läge. Standardvärdet för PS4 är + skylt

Ovanstående skript genererar en loggfil som heter debug_report.log, för att läsa den, använd katt kommando:

Slutsats:

En kod full av buggar kan också påverka programmets prestanda och vara skadlig för hårdvaran. Felsökning är mycket avgörande för varje program eftersom det gör programmet mer effektivt. Att hitta befintliga och potentiella fel under utvecklingen av ett program kan förhindra att ditt program uppför sig oväntat. Stora koder behöver vanligtvis aktiv felsökning, vilket förbättrar kodens effektivitet genom att eliminera de resurskrävande bitarna av kod.

Många programmeringsspråk och miljöer har sina egna följeslagare. I bash scripting kan olika tekniker implementeras för att felsöka scriptet. Den här guiden fokuserade grundligt på alla metoder som kan användas för att hitta buggar i bash -skripten. Så när du känner att ditt bash-skript inte beter sig som förväntat, använd någon av de tekniker som nämns ovan, men xtrace-läge (-x) är ganska användbart i de flesta fall.