Hvordan feilsøke et bashskript?

Ethvert program må være fri for feil før det når forbrukerne. Programvareutviklere prøver sitt beste for å gjøre programvarene til feilfri. Men det er vanskelig å gjøre en kode feilfri når det er tusenvis av linjer. Feilsøking er en pågående prosess; Det hjelper med å oppdage feil umiddelbart, samle verdifull informasjon om kode og eliminere overflødige kodebiter.

Alle programmeringsspråk har noen vanlige og få forskjellige tilnærminger for å finne feil. For eksempel kan feilsøkingsprogrammer brukes til å fjerne feil raskt. Mens skallskripting ikke har noe bestemt verktøy for å feilsøke koden. Denne oppskrivningen handler om å diskutere forskjellige feilsøkingsteknikker som kan brukes til å gjøre Bash-skriptet feilfri. Før vi dykker ned i metodene, la oss ha en grunnleggende forståelse av skjell og skallskripting:

Hva er skallet i Linux?

Når du starter opp datamaskinen, får kjernen informasjon om vedlagte maskinvare og lar andre vedlagte komponenter samhandle. Bortsett fra det, administrerer det minne, CPU og gjenkjenner enhver ny perifert. Alt i alt er en kjerne ryggraden i ethvert operativsystem. Men har du noen gang tenkt å samhandle direkte med kjernen, kommandere den til å utføre en spesifikk oppgave? Er det til og med praktisk å gjøre det? Absolutt! Ved hjelp av et skall, et dataprogram med et interaktivt grensesnitt, kan hvem som helst betjene kjernen. Skallet lar mennesker samhandle med kjernen og instruere det til å utføre enhver oppgave.

I Unix er det to hovedskall Bourne Shell og C Shell. Begge disse typene har sine underkategorier. Ulike typer Bourne -skjell er Korn Shell (KSH), Almquist Shell (Ash), Bourne Again Shell (Bash), og Z Shell (Zsh). Samtidig har C -skallet sine egne underkategorier som C Shell (CSH) og Tenx C Shell (TCSH). Som nevnt ovenfor, av alle skjellene, Bash (Bourne Again Shell) er det mest brukte skallet og kommer ut av boksen i mange Linux-distribusjoner på grunn av effektiviteten og brukervennligheten.

Bash er standardskallet for mange Linux -distribusjoner og brukes mye av millioner av Linux -brukere. Det er så mangfoldig og innflytelsesrik at det kan utføre hver oppgave du vanligvis utfører i GUI-baserte applikasjoner. Du kan redigere filer, administrere filer, se bilder, lytte til musikk, spille av videoer og mye mer.

Hva er et skallskript:

Som vi har lært den grunnleggende ideen om Shell, la oss nå gå mot Shell Scripting. Shell -skriptet er et dataprogram som utfører flere kommandoer i et skall som fungerer som tolk for å utføre en spesifikk funksjon. Som diskutert ovenfor, er det to bestemte typer skjell. Imidlertid fokuserer denne guiden på Bourne Again Shell (bash).
Så hva er et bashskript? I Linux er alle bash -kommandoene lagret i “/Usr/bin” og “/bin” mapper. For eksempel, når du kjører en kommando, søker Bash hvis den finnes i katalogen eller ikke. Kommandoen blir utført hvis den finner i katalogene ellers gir en feil.

Hva med å utføre en oppgave som trenger flere kommandoer for å kjøre i terminalen? I denne spesifikke situasjonen kan bashskripting hjelpe deg. Bash Scripting er en form for skallskripting som lar deg lage programmer for å kjøre flere bash -kommandoer for å utføre en spesifikk oppgave.

Hva er feil i bashskripting:

Når du jobber med bash -skripting eller med andre programmeringsspråk, møter du mange feil. En feil er en feil eller en feil i programmet som kan føre til at programmet oppfører seg feil.

Hvert programmeringsspråk har sin egen prosedyre for å finne feil; Tilsvarende har Bash også mange innebygde alternativer for å feilsøke et terminalprogram.

Administrere feil og feilsøking av et program er ikke mindre enn et problem. Det er en tidkrevende jobb og kan forverres hvis du ikke er klar over de riktige verktøyene for å feilsøke programmet ditt. Denne oppskrivningen er en komplett guide om feilsøking av bash-skripte for å gjøre skriptet feilfri. Så la oss begynne:

Hvordan feilsøke et bashskript:

Når du jobber med store programmeringsprosjekter, møter du mange feil eller feil. Feilsøking av et program kan noen ganger være komplisert. Programmerere bruker vanligvis feilsøkingsverktøy, og mange kodedaktører hjelper også med å finne feil ved å fremheve syntaks.

Det er forskjellige verktøy i Linux for å feilsøke koder, for eksempel GNU Debugger aka “GDB.”Verktøy som GDB er nyttige for programmeringsspråk som samles i binærene. Siden bash er et enkelt tolket språk, er det ikke behov for tunge verktøy for å feilsøke det.

Det er forskjellige tradisjonelle teknikker for å feilsøke en bash -skriptkode, og en av dem legger til “Påstander.” Påstander er forhold som er lagt til i programmene for å sjekke spesifikke forhold og utføre programmet deretter. Det er en defensiv teknikk som hjelper til med å finne feil og testing også. Du kan finne mange verktøy som hjelper deg med å legge til påstander i bash -skript.

Vel, å legge til påstander er en av de gamle tradisjonelle teknikkene. Det er sett med flagg/alternativer tilgjengelig i bash for å feilsøke et bash -manus. Disse alternativene kan legges til sammen med Shebang i skriptene eller legges til mens du utfører programmet i terminalen. Temaene vi skal ta opp er listet opp nedenfor:

1. Hvordan feilsøke Bash -skriptet ved å aktivere Verbose “-V” alternativ
2. Hvordan feilsøke Bash -skriptet ved hjelp av Xtrace “-x” alternativ
3. Hvordan feilsøke Bash -skriptet ved hjelp av NOEXEC “-N” alternativ
4. Hvordan identifisere useset -variabler Mens feilsøking av bash -manus
5. Hvordan feilsøke spesifikk del av bashskriptet
6. Hvordan feilsøke et bash -skript ved hjelp av "felle" kommando
7. Hvordan feilsøke et bash -manus ved å eliminere fil globbing bruker “-F” alternativ
8. hvordan kombinere Feilsøkingsalternativer for å feilsøke et skallskript
9. hvordan omdirigere debugrapport til en fil

Så la oss sjekke forskjellige teknikker i bash for å feilsøke et bash -manus:

Hvordan feilsøke Bash-skriptet ved å aktivere Verbose “-V” -alternativ:

En av de enkleste tilnærmingene til å feilsøke bashskriptet er å bruke “-V” Alternativ, også kjent som Verbose. Alternativet kan legges til med Shebang eller eksplisitt settes med skriptfilnavnet mens du utfører det. Verbose -alternativet vil utføre og skrive ut hver linje i koden som prosessen av tolken. La oss forstå det med et bash -manuseksempel:

#! /bin/bash
ekko "Enter Number1"
Les nummer1
ekko "Angi nummer2"
Les nummer2
hvis ["$ nummer1" -gt "$ nummer2"]
deretter
Echo "Number1 er større enn nummer2"
elif ["$ number1" -eq "$ nummer2"]
deretter
Echo "Number1 er lik nummer2"
ellers
Echo "Number2 er større enn nummer1"
fi

Ovennevnte kode får to tall fra brukeren og utfører deretter noen betingede utsagn for å sjekke om nummeret er mer betydelig, mindre eller lik det andre angitte nummeret. Selv om enhver tekstredigerer kan brukes til bash scripting, bruker jeg vim editor. VIM er en kraftig, funksjonsrik redaktør som fremhever syntaksen til bash-skript og reduserer sjansene for syntaksfeil. Hvis du ikke har VIM -redaktør, få det ved å kjøre kommandoen nevnt nedenfor:

$ sudo apt install vim

Lag en bash -skriptfil ved hjelp av:

$ vim b_script.sh

Hvis du er ny på VIM -redaktøren, anbefaler jeg at du lærer hvordan du bruker VIM -redaktøren før du fortsetter.

Nå, tilbake til skriptet, utfør skriptet ved å bruke “-V” alternativ:

$ bash -v b_script.sh

Det kan sees i output output at hver linje i skriptet skrives ut i terminalen når de behandler av tolken. Merk at skriptet vil slutte å ta innspill fra brukeren og deretter behandle den neste linjen i skriptet. Som diskutert ovenfor at “-V” Alternativet kan plasseres etter Shebang som vist på følgende:

#! /bin/bash -v

Tilsvarende kan det ordrike flagget også legges til i neste linje med Shebang ved å bruke "sett" kommando:

#! /bin/bash
sett -v

Noen av metodene omtalt ovenfor kan muliggjøre verbose.

2 Hvordan feilsøke Bash-skriptet ved hjelp av Xtrace “-x” -alternativ:

Utførelsesspor, også kjent som Xtrace er et smart og nyttig feilsøkingsalternativ, spesielt for å spore logiske feil. Logiske feil er vanligvis assosiert med variabler og kommandoer. For å sjekke tilstanden til variabelen under utførelsen av skriptet, bruker vi “-X” alternativ. Nå igjen, løp “B_script.sh ” fil med “-X” flagg:

$ bash -x b_script.sh

Utgangen viser eksplisitt verdien av hver variabel under utførelsesprosessen. Igjen, den “-X” kan brukes ved siden av Shebang og etter Shebang -linjen ved hjelp av den angitte kommandoen. Xtrace setter “+” -tegnet med hver linje i skriptet.

3 Hvordan feilsøke Bash-skript ved hjelp av NOEXEC “-N” -alternativ:

Syntaksfeil er en av de viktigste årsakene til feil. For syntaktisk feilsøking av bashskriptet, bruker vi “NOEXEC” (Ingen utførelse) -modus. Alternativet som brukes til NOEXEC -modus er “-N.” Den vil bare vise syntaksfeilene til koden i stedet for å utføre den. En mye tryggere tilnærming til feilsøking av koden. La oss henrette “B_script.sh ” igjen med “-N” alternativ:

$ bash -n b_script.sh

Det vil ikke være noen utførelse av kode hvis det ikke er noen syntaksfeil. La oss nå endre koden vår:

#! /bin/bash
ekko "Enter Number1"
Les nummer1
ekko "Angi nummer2"
Les nummer2
hvis ["$ nummer1" -gt "$ nummer2"]
deretter
Echo "Number1 er større enn nummer2"
elif ["$ number1" -eq "$ nummer2"]
#deretter
Echo "Number1 er lik nummer2"
ellers
Echo "Number2 er større enn nummer1"
fi

Jeg kommenterer "deretter" etter “Elif”. Nå, med "-n" utfør “B_script.sh ” manus:

$ bash -n b_script.sh

Som forventet identifiserte den tydelig feilen og viste den i terminalen.

4 Slik identifiserer du usesetvariablene mens du feilsøker bash -skriptet:

Å lage en skrivefeil mens du skriver en kode er vanlig. Ofte tar du feil av en variabel, som ikke lar koden utføre. For å identifisere en slik feil, bruker vi “-U” alternativ. La oss endre koden igjen:

#! /bin/bash
ekko "Enter Number1"
Les nummer1
ekko "Angi nummer2"
Les nummer2
hvis ["$ num1" -gt "$ nummer2"]
deretter
Echo "Number1 er større enn nummer2"
elif ["$ number1" -eq "$ nummer2"]
deretter
Echo "Number1 er lik nummer2"
ellers
Echo "Number2 er større enn nummer1"
fi

I det første "hvis" betinget uttalelse, jeg ga nytt navn til “Nummer1” variabel til “Num1”. Nå “Num1” er en ikke -set variabel. Kjør nå skriptet:

$ bash -u b_script.sh

Utgangen har identifisert og viser eksplisitt navnet på en useset variabel.

Hvordan feilsøke den spesifikke delen av bashskriptet:

Xtrace -modus behandler hver linje i koden og gir utdata. Å finne feil i en stor kode vil imidlertid være tidkrevende hvis vi allerede vet hvilken del som potensielt forårsaker feilen. Heldigvis lar Xtrace deg også feilsøke en bestemt del av koden, som kan oppnås ved hjelp av "sett" kommando. Plass “Sett -x” i begynnelsen av delen som må feilsøkes og deretter “Sett +x” på slutten. For eksempel vil jeg feilsøke de betingede uttalelsene fra “B_script.sh ”, Så jeg vil omslutte alle betingede uttalelser i “Sett -x” og “Sett +x” Alternativer som vist i koden nedenfor:

#! /bin/bash
ekko "Enter Number1"
Les nummer1
ekko "Angi nummer2"
Les nummer2
sett -x
hvis ["$ nummer" -gt "$ nummer2"]
deretter
Echo "Number1 er større enn nummer2"
elif ["$ number1" -eq "$ nummer2"]
deretter
Echo "Number1 er lik nummer2"
ellers
Echo "Number2 er større enn nummer1"
fi
sett +x

Kjør nå skriptet ved hjelp av “Bash B_Script.sh ”.

Utgangen er bare feilsøking av IF -forhold som spesifisert.

Hvordan feilsøke et bash -skript ved hjelp av “Trap” -kommandoen:

Hvis skriptet ditt er komplisert, er det mer utdypende teknikker også for feilsøking. En av dem er "felle" kommando. De "felle" Kommandoen fanger signalene og utfører en kommando når en spesifikk situasjon oppstår. Kommandoen kan være et signal eller en funksjon. Jeg har laget et annet manus ved navn “Sum_script.sh ”:

#! /bin/bash
Trap 'Echo "Line $ Lineno: Første nummer er $ nummer1, andre nummer er $ nummer2 og summen er $ sum"' Debug
ekko "Angi første nummer"
Les nummer1
ekko "Angi andre nummer"
Les nummer2
sum = $ [nummer1 + nummer2]
ekko "summen er $ sum"

De "felle" kommando med “Debug” Signal viser statusen til variablene “Nummer1”, "Nummer 2" og "sum" Etter utførelsen av hver linje som vist i følgende utgangsbilde:

De gule blokkene er tomme mellomrom fordi brukeren ennå ikke har angitt noen innspill; Disse mellomrommene vil fylle ut når brukeren legger inn verdier. Denne metoden er også ganske nyttig i feilsøking av bash -skript.

Hvordan feilsøke et bash-skript ved å eliminere File Globbing ved hjelp av “-F” -alternativet:

File Globbing er en prosess for å finne filene med jokertegn, i.e., “*” og “?”. I mange situasjoner trenger du ikke utvide filer mens du feilsøker. I slike tilfeller kan du blokkere filen Globbing ved hjelp av “-F” alternativ. La oss forstå det med et skript “FGLOBE_SCRIPT.sh ”:

#! /bin/bash
ekko "Vis alle tekstfiler.""
ls *.tekst

Ovennevnte kode vil vise alle tekstfilene i den gjeldende katalogen, utfør:

$ BASH FGLOBE_SCRIPT.sh

For å slå av File Globbing, bruk “-F” alternativ:

$ bash -f fglobe_script.sh

Tilsvarende kan du bruke den med Shebang og med "sett" Kommando også:

#! /bin/bash
ekko "Vis alle tekstfiler.""
ls *.tekst
sett -f
ekko "Vis alle tekstfiler"
ls *.tekst
sett +f

Nå, løp “Bash fglobe_script.sh ”:

Delen vedlagt med “Set -f/Set +F” Alternativene behandlet ikke kommandoer med jokertegn.

Hvordan kombinere feilsøkingsalternativer for å feilsøke skallskriptet:

Vi bruker bare ett alternativ i ovennevnte feilsøkingsteknikker, men vi kan kombinere forskjellige alternativer for bedre forståelse. La oss implementere “-X” og “-V” alternativer til “Sum_script.sh ” manus. Jeg bruker “Sum_script.sh ” manus.

#! /bin/bash
ekko "Angi første nummer"
Les nummer1
ekko "Angi andre nummer"
Les nummer2
sum = $ [nummer1 + nummer2]
ekko "summen er $ sum"

Nå utfør:

$ bash -xv sum_script.sh

Både “-X” og “-V” Utgangene kombineres, som vist i utgangsbildet. Tilsvarende kan vi også kombinere “-U” Alternativ med verbose “-v” for feildeteksjon. Jeg erstatter “Nummer1” variabel med “Num” I den sjette linjen i manuset:

#! /bin/bash
er $ nummer2 og summen er $ sum "'Debug
ekko "Angi første nummer"
Les nummer1
ekko "Angi andre nummer"
Les nummer2
sum = $ [num + nummer2]
ekko "summen er $ sum"

For å se utdataene, kjør den under-nevnte kommandoen:

$ bash -uv sum_script.sh

Hvordan omdirigere feilsøkingsrapport til en fil:

Å lagre en feilsøkingsrapport om et bash -skript til en fil kan være nyttig i mange situasjoner. Det er litt vanskelig fordi å omdirigere debugrapport til en fil; Vi bruker noen spesielle variabler. La oss implementere det på “B_script.sh ” kode:

#! /bin/bash
exec 5> dubug_report.Logg
Bash_xtraced = "5"
PS4 = '$ Lineno--'
ekko "Enter Number1"
Les nummer1
ekko "Angi nummer2"
Les nummer2
hvis ["$ nummer" -gt "$ nummer2"]
deretter
Echo "Number1 er større enn nummer2"
elif ["$ number1" -eq "$ nummer2"]
deretter
Echo "Number1 er lik nummer2"
ellers
Echo "Number2 er større enn nummer1"
fi

I den andre linjen i koden kan det sees at vi omdirigerer utdataene til en “Debug_report.Logg" fil ved hjelp av “Exec” Kommando med filbeskrivelse 5 (FD5).

exec 5> debug_report.Logg: De “Exec” Kommandoen omdirigerer alt som skjer i skallet til en fil “Debug_report.Logg.”

Bash_xtracefd = ”5”: Det er en bestemt bashvariabel og kan ikke brukes i noe annet skall. Det må tildeles en gyldig filbeskrivelse, og Bash vil skrive den ekstraherte utdataene til “Debug_report.Logg.”

PS4 = '$ Lineno- ': Det er også en bashvariabel som brukes til å skrive ut linjenummeret mens du feilsøker med Xtrace -modus. Standardverdien på PS4 er “+” skilt

Ovennevnte skript genererer en loggfil som heter “Debug_report.Logg," For å lese den, bruk "katt" kommando:

Konklusjon:

En kode full av feil kan påvirke programmets ytelse og også skadelig for maskinvaren. Feilsøking er veldig avgjørende for hvert program siden det gjør programmet mer effektivt. Å finne eksisterende og potensielle feil under utviklingen av et program kan forhindre at programmet ditt oppfører seg uventet. Store koder trenger vanligvis aktiv feilsøking, noe.

Mange programmeringsspråk og miljøer har sine egne følgesvenn. I bash -skripting kan forskjellige teknikker implementeres for å feilsøke manuset. Denne guiden fokusert grundig på alle metodene som kan brukes til å finne feil i bashskriptene. Så når du føler at Bash-skriptet ditt ikke oppfører seg som forventet, bruk noen av teknikkene som er nevnt ovenfor, men XTrace Mode (-X) er ganske nyttig i de fleste tilfeller.