Variabler er essensielle for å skrive skript og for å forstå funksjonen til kode som kopieres og limes inn fra nettet på en Linux-maskin. Denne veiledningen hjelper deg i gang med det grunnleggende!
Grunnleggende om variabler
Variabler er symboler med et navn som representerer en tekststreng eller en numerisk verdi. Når de brukes i kommandoer eller uttrykk, behandles de som om du hadde skrevet inn den faktiske verdien i stedet for variabelnavnet.
For å opprette en variabel, trenger du bare å spesifisere et navn og en verdi. Velg beskrivende variabelnavn som minner deg om verdien de inneholder. Et variabelnavn må ikke begynne med et tall eller inneholde mellomrom. Det kan imidlertid starte med en understrek. Ellers kan du bruke en hvilken som helst kombinasjon av store og små alfanumeriske tegn.
Eksempler på bruk av variabler
La oss lage fem variabler. Formatet er å skrive navnet, likhetstegnet (=) og verdien. Det er viktig å merke seg at det ikke skal være mellomrom før eller etter likhetstegnet. Det å gi en variabel en verdi, kalles ofte for å tilordne en verdi til variabelen.
Vi oppretter fire tekststrengvariabler og en numerisk variabel, `this_year`:
me=Dave
my_boost=Linux
him=Popeye
his_boost=Spinach
this_year=2019
For å vise verdien som er lagret i en variabel, brukes `echo`-kommandoen. Du må sette et dollartegn ($) foran variabelnavnet hver gang du refererer til verdien den inneholder, som vist nedenfor:
echo $me
echo $my_boost
echo $this_year
La oss bruke alle variablene våre samtidig:
echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"
Verdiene til variablene erstatter navnene deres. Du kan også endre verdiene til variabler. For å tilordne en ny verdi til variabelen `my_boost`, gjentar du prosessen du brukte da du tilordnet den første verdien, slik:
my_boost=Tequila
Hvis du kjører den forrige kommandoen på nytt, får du nå et annet resultat:
echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"
Så du kan bruke den samme kommandoen som refererer til de samme variablene og få forskjellige resultater hvis du endrer verdiene i variablene.
Vi skal diskutere sitering av variabler senere. For nå er det noen ting du bør huske på:
- En variabel innenfor enkle anførselstegn («) behandles som en bokstavelig tekststreng, ikke som en variabel.
- Variabler innenfor doble anførselstegn («) behandles som variabler.
- For å få verdien lagret i en variabel, må du bruke dollartegnet ($).
- En variabel uten dollartegnet ($) viser bare navnet på variabelen.
Du kan også opprette en variabel som henter verdien fra en eksisterende variabel eller kombinasjonen av flere variabler. Følgende kommando definerer en ny variabel kalt `drink_of_the_year` og tilordner den den kombinerte verdien av variablene `my_boost` og `this_year`:
drink_of_the_Year="$my_boost $this_year"
echo $drink_of_the_Year
Hvordan bruke variabler i skript
Skript ville ikke vært det samme uten variabler. Variabler gir fleksibilitet og gjør et skript til en generell, i stedet for en spesifikk, løsning. For å illustrere forskjellen, se på et skript som teller antall filer i `/dev`-mappen.
Skriv dette inn i en tekstfil, og lagre den som `fcnt.sh` (for «filantall»):
#!/bin/bash folder_to_count=/dev file_count=$(ls $folder_to_count | wc -l) echo $file_count filer i $folder_to_count
Før du kan kjøre skriptet, må du gjøre det utførbart, som vist nedenfor:
chmod +x fcnt.sh
Skriv inn følgende for å kjøre skriptet:
./fcnt.sh
Dette skriver ut antall filer i `/dev`-mappen. Slik fungerer det:
- En variabel kalt `folder_to_count` er definert, og verdien er tekststrengen «/dev».
- En annen variabel, kalt `file_count`, defineres. Denne variabelen henter verdien fra en kommandoerstatning. Dette er kommandofrasen mellom parentesene `$( )`. Det er et dollartegn ($) før den første parentesen. Denne konstruksjonen `$( )` evaluerer kommandoene inni parentesen og returnerer deretter den endelige verdien. I dette eksemplet er den verdien tilordnet til variabelen `file_count`. Når det gjelder variabelen `file_count`, har den fått en verdi som skal lagres. Den bryr seg ikke om hvordan verdien ble oppnådd.
- Kommandoen som evalueres i kommandoerstatningen utfører en `ls`-filoppføring i mappen i variabelen `folder_to_count`, som er satt til «/dev». Så skriptet utfører kommandoen «ls /dev».
- Utdataene fra denne kommandoen overføres til kommandoen `wc`. Alternativet `-l` (linjetelling) fører til at `wc` teller antall linjer i utdataene fra ls-kommandoen. Siden hver fil vises på en egen linje, er dette antall filer og undermapper i `/dev`-mappen. Denne verdien er tilordnet variabelen `file_count`.
- Den siste linjen bruker echo for å skrive ut resultatet.
Men dette fungerer bare for `/dev`-mappen. Hvordan kan vi få skriptet til å fungere med en hvilken som helst mappe? Alt som trengs er en liten endring.
Hvordan bruke kommandolinjeparametere i skript
Mange kommandoer, som `ls` og `wc`, tar kommandolinjeparametere. Disse gir informasjon til kommandoen, slik at den vet hva du vil at den skal gjøre. Hvis du vil at `ls` skal jobbe med hjemmemappen din og også vise skjulte filer, kan du bruke følgende kommando, der tilde (~) og `-a`-alternativet (alle) er kommandolinjeparametere:
ls ~ -a
Skriptene våre kan godta kommandolinjeparametere. De refereres til som `$1` for den første parameteren, `$2` for den andre, og så videre, opp til `$9` for den niende parameteren. (Det finnes faktisk også en `$0`, men den er reservert for alltid å holde skriptnavnet.)
Du kan referere til kommandolinjeparametere i et skript akkurat som vanlige variabler. La oss endre skriptet vårt, som vist nedenfor, og lagre det med det nye navnet `fcnt2.sh`:
#!/bin/bash folder_to_count=$1 file_count=$(ls $folder_to_count | wc -l) echo $file_count filer i $folder_to_count
Denne gangen blir variabelen `folder_to_count` tilordnet verdien av den første kommandolinjeparameteren, `$1`.
Resten av skriptet fungerer akkurat som før. I stedet for en spesifikk løsning, er skriptet ditt nå mer generelt. Du kan bruke den på en hvilken som helst mappe, siden den ikke er hardkodet til å bare fungere med «/dev».
Slik gjør du skriptet utførbart:
chmod +x fcnt2.sh
Prøv nå med noen få mapper. Du kan starte med «/dev» for å sørge for at du får samme resultat som før. Skriv inn følgende:
./fcnt2.sh /dev
./fcnt2.sh /etc
./fcnt2.sh /bin
Du får samme resultat (207 filer) som før for «/dev»-mappen. Dette er bra, og du får m spesifikke resultater for hver av de andre kommandolinjeparametrene.
For å forkorte skriptet, kan du utelate variabelen `folder_to_count` helt og bare referere til `$1` gjennom hele skriptet, slik som dette:
#!/bin/bash file_count=$(ls $1 | wc -l) echo $file_count filer i $1
Arbeid med spesielle variabler
Vi nevnte `$0`, som alltid er satt til filnavnet til skriptet. Dette lar deg bruke skriptet til å gjøre ting som å skrive ut navnet på en god måte, selv om det er blitt omdøpt. Dette er nyttig i loggsituasjoner, der du vil vite navnet på prosessen som la til en oppføring.
Følgende er de andre spesielle forhåndsinnstilte variablene:
- `$#`: Hvor mange kommandolinjeparametere ble sendt til skriptet.
- `$@`: Alle kommandolinjeparametere som ble sendt til skriptet.
- `$?:` Utgangsstatusen til den siste prosessen som ble kjørt.
- `$$`: Prosess-ID (PID) for det aktuelle skriptet.
- `$USER`: Brukernavnet til brukeren som kjører skriptet.
- `$HOSTNAME`: Vertsnavnet til datamaskinen som kjører skriptet.
- `$SECONDS`: Antall sekunder skriptet har kjørt i.
- `$RANDOM`: Returnerer et tilfeldig tall.
- `$LINENO`: Returnerer gjeldende linjenummer for skriptet.
Vil du se alle i ett skript? Du kan det! Lagre følgende som en tekstfil kalt `special.sh`:
#!/bin/bash echo "Det var $# kommandolinjeparametere" echo "De er: $@" echo "Parameter 1 er: $1" echo "Skriptet heter: $0" # en tilfeldig prosess slik at vi kan rapportere om utgangsstatusen pwd echo "pwd returnerte $?" echo "Dette skriptet har prosess-ID $$" echo "Skriptet ble startet av $USER" echo "Det kjører på $HOSTNAME" sleep 3 echo "Det har kjørt i $SECONDS sekunder" echo "Tilfeldig tall: $RANDOM" echo "Dette er linjenummer $LINENO i skriptet"
Skriv inn følgende for å gjøre det utførbart:
chmod +x special.sh
Nå kan du kjøre det med en rekke ulike kommandolinjeparametere, som vist nedenfor.
Miljøvariabler
Bash bruker miljøvariabler til å definere og registrere egenskapene til miljøet det oppretter når det startes. Disse inneholder informasjon som Bash enkelt kan få tilgang til, for eksempel brukernavnet ditt, språk, antall kommandoer historiefilen din kan inneholde, standard redigeringsprogram og mye mer.
For å se de aktive miljøvariablene i Bash-økten din, bruker du denne kommandoen:
env | less
Hvis du blar gjennom listen, kan du finne noen som er nyttige å referere til i skriptene dine.
Hvordan eksportere variabler
Når et skript kjører, er det i sin egen prosess, og variablene det bruker kan ikke sees utenfor denne prosessen. Hvis du vil dele en variabel med et annet skript som skriptet ditt starter, må du eksportere variabelen. Vi viser deg hvordan du gjør dette med to skript.
Først lagrer du følgende med filnavnet `script_one.sh`:
#!/bin/bash first_var=alpha second_var=bravo # sjekk verdiene echo "$0: first_var=$first_var, second_var=$second_var" export first_var export second_var ./script_two.sh # sjekk verdiene igjen echo "$0: first_var=$first_var, second_var=$second_var"
Dette oppretter to variabler, `first_var` og `second_var`, og tilordner dem noen verdier. Det skriver ut disse til terminalvinduet, eksporterer variablene og kaller `script_two.sh`. Når `script_two.sh` er ferdig, og prosessflyten går tilbake til dette skriptet, skriver det ut variablene til terminalvinduet igjen. Dermed kan du se om de har endret seg.
Det andre skriptet vi skal bruke er `script_two.sh`. Dette er skriptet som `script_one.sh` kaller opp. Skriv inn følgende:
#!/bin/bash # sjekk verdiene echo "$0: first_var=$first_var, second_var=$second_var" # sett nye verdier first_var=charlie second_var=delta # sjekk verdiene igjen echo "$0: first_var=$first_var, second_var=$second_var"
Dette andre skriptet skriver ut verdiene til de to variablene, tilordner dem nye verdier, og skriver dem deretter ut igjen.
For å kjøre disse skriptene, må du skrive inn følgende for å gjøre dem kjørbare:
chmod +x script_one.sh chmod +x script_two.sh
Og nå skriver du inn følgende for å starte `script_one.sh`:
./script_one.sh
Dette er hva utdataene forteller oss:
- `script_one.sh` skriver ut verdiene til variablene, som er alfa og bravo.
- `script_two.sh` skriver ut verdiene til variablene (alfa og bravo) slik de mottok dem.
- `script_two.sh` endrer dem til charlie og delta.
- `script_one.sh` skriver ut verdiene til variablene, som fremdeles er alfa og bravo.
Det som skjer i det andre skriptet, blir i det andre skriptet. Det er som om kopier av variablene sendes til det andre skriptet, men de forkastes når det skriptet avsluttes. De originale variablene i det første skriptet endres ikke av noe som skjer med kopiene av dem i det andre.
Hvordan sitere variabler
Du har kanskje lagt merke til at når skript refererer til variabler, er de omsluttet av anførselstegn («). Dette sørger for at variablene refereres riktig, slik at deres verdier brukes når linjen utføres i skriptet.
Hvis verdien du tilordner en variabel, inneholder mellomrom, må de omsluttes med anførselstegn når du tilordner dem til variabelen. Dette er fordi Bash som standard bruker mellomrom som skilletegn.
Her er et eksempel:
site_name=How-To Geek
Bash ser mellomrommet før «Geek» som en indikasjon på at en ny kommando starter. Det rapporteres at det ikke finnes en slik kommando, og linjen avsluttes. `echo` viser at variabelen `site_name` ikke inneholder noe, ikke engang teksten «How-To».
Prøv det igjen med anførselstegn rundt verdien, som vist nedenfor:
site_name="How-To Geek"
Denne gangen gjenkjennes den som én enkelt verdi og tilordnes riktig til variabelen `site_name`.
`echo` er din venn
Det kan ta litt tid å venne seg til kommandoerstatning, sitering av variabler og å huske når du skal inkludere dollartegnet ($).
Før du trykker på Enter og utfører en linje med Bash-kommandoer, prøv den med `echo` foran. På denne måten kan du sørge for at det som skal skje er det du ønsker. Du kan også fange eventuelle feil du måtte ha gjort i syntaksen.