Lær Bash-skripting: 5 enkle eksempler for Linux

0 Shares

Bash-skripting er en utbredt og tilgjengelig metode for å programmere din Linux-maskin. Disse enkle skripteksemplene vil hjelpe deg å forstå hvordan prosessen fungerer og introdusere deg til fundamentale konsepter innen Bash-programmering.

1. Hvordan skrive ut «Hello World» i Bash

Å skrive ut «Hello World» er en klassisk start for å lære et hvilket som helst programmeringsspråk, og Bash er ikke et unntak.

Her er fremgangsmåten for å skrive ut «Hello World» i Bash:

Start med å åpne en teksteditor og opprett en ny fil. Legg til følgende kode i denne filen.
Den første linjen i dine Bash-skript bør alltid være:
```
 #!/bin/bash 
```
Shebang-kommandoen (#!/bin/bash) er avgjørende fordi den forteller skallet hvordan skriptet skal utføres. I dette tilfellet angir den at Bash-tolken skal brukes.
En linje som begynner med et #-symbol er en kommentar. Shebang-linjen er et spesialtilfelle, men du kan også legge til egne kommentarer for å gjøre koden lettere å forstå. Legg til en kommentar på linje 2, for eksempel:
```
  # Dette er et enkelt Hello World-skript 
```
Du kan skrive ut tekst til standard utdata ved hjelp av kommandoen `echo`, etterfulgt av teksten du ønsker å vise. Legg til følgende på linje 3:
```
 echo "Hello World" 
```
Lagre skriptet med et passende navn, gjerne med filtypen `.sh`, for eksempel `hello_world.sh`. Filtypen er ikke et krav, men det er en nyttig konvensjon å følge.
For å kunne kjøre skriptet, må filen gjøres kjørbar. Dette gjøres med kommandoen `chmod` (endre modus) i kombinasjon med argumentet `+x` (kjørbar) og navnet på skriptfilen:
```
 chmod +x hello_world.sh 
```
Kjør skriptet fra katalogen det ligger i med følgende kommando:
```
 ./hello_world.sh 
```
Når skriptet kjøres, vil det skrive ut teksten «Hello World» i terminalen:

2. Lag en mappe ved å lese input

Fra dine skript kan du utføre alle programmer som du normalt ville kjøre i kommandolinjen. Du kan for eksempel lage en ny mappe ved hjelp av kommandoen `mkdir`.

Start med samme shebang-linje som tidligere:
```
 #!/bin/bash 
```
Spør brukeren om navnet på den nye mappen ved å bruke `echo`-kommandoen:
```
 echo "Skriv inn navnet på den nye mappen:" 
```
Bruk den innebygde `read`-kommandoen for å hente brukerens input. Argumentet angir en variabel som skallet bruker for å lagre input:
```
 read nymappe 
```
For å bruke verdien lagret i en variabel, setter du et dollartegn ($) foran navnet. Du kan gi innholdet i `nymappe`-variabelen som argument til `mkdir`-kommandoen for å opprette den nye mappen:
```
 mkdir $nymappe 
```
Når du kjører dette skriptet, vil det be deg om å skrive inn et navn. Skriv inn et gyldig mappenavn, og skriptet vil opprette den i din nåværende katalog:

3. Lag en mappe ved hjelp av kommandolinjeargumenter

Som et alternativ til å lese inn data interaktivt, støtter de fleste Linux-kommandoer argumenter. Du kan gi et argument når du kjører et program for å kontrollere hvordan det skal oppføre seg.

I skriptet ditt kan du bruke `$1` for å referere til en spesiell variabel som inneholder verdien av det første argumentet. `$2` vil referere til det andre argumentet, og så videre.

Lag en mappe med `mkdir`-kommandoen, slik som i det forrige eksempelet. Men denne gangen bruker du den innebygde variabelen `$1`:
```
 #!/bin/bash
mkdir $1 
```
Kjør skriptet, men denne gangen sender du det valgte navnet på en ny mappe som et argument:
```
 ./arg_mappe.sh Test 
```

Du lurer kanskje på hva som skjer hvis du kjører skriptet uten å oppgi et argument. Prøv det og se; du vil motta en feilmelding som starter med «bruk: mkdir»:

Uten noen kommandolinjeargumenter vil verdien av `$1` være tom. Når skriptet kaller `mkdir`, vil det ikke sende et argument, og kommandoen `mkdir` vil returnere denne feilen. For å unngå dette kan du sjekke tilstanden selv og presentere en mer brukervennlig feilmelding:

Start som alltid med shebang-linjen:
```
 #!/bin/bash 
```
Før du kaller `mkdir`, sjekk om det første argumentet er tomt (dvs. ingen argumenter ble oppgitt). Dette kan du gjøre med en `if`-setning i Bash, som utfører kode basert på en betingelse:
```
 if ["$1" = ""]; then 
```
Hvis det første argumentet er tomt, skriv ut en feilmelding og avslutt skriptet:
```
  echo "Vennligst oppgi et mappenavn som det første argumentet" 
 exit 
```
Det litt merkelige nøkkelordet «fi» (som er «if» baklengs) signaliserer slutten på en `if`-setning i Bash:
```
 fi 
```
Skriptet kan nå fortsette som før og håndtere tilfellet der et argument er oppgitt:
```
 mkdir $1 
```

Når du kjører denne nye versjonen av skriptet, vil du få en melding hvis du glemmer å legge inn et argument:

4. Slett en fil med en Bash-funksjon

Hvis du ofte finner deg selv å gjenta den samme koden, bør du vurdere å samle den i en funksjon. Du kan deretter kalle den funksjonen når du trenger den.

Her er et eksempel på en funksjon som sletter en angitt fil.

Start med shebang-linjen:
```
 #!/bin/bash 
```
Definer en funksjon ved å skrive navnet, etterfulgt av tomme parenteser og kommandoer inni krøllete parenteser:
```
 slett_fil() {
 echo "Sletter $1"
 rm $1
} 
```
Deretter kan du kalle funksjonen og gi den navnet på filen som skal slettes:
```
 slett_fil test.txt 
```

Når du kaller en funksjon, setter den den spesielle `$?`-verdien med utgangsstatusen til den siste kommandoen den kjører. Utgangsstatusen er nyttig for feilsjekk; i dette eksemplet kan du teste om `rm`-kommandoen var vellykket:

 if [ $? -ne 0 ]; then
 echo "Beklager, kunne ikke slette filen"
fi

5. Lag en enkel kalkulator for aritmetiske beregninger

Dette siste eksemplet viser en veldig enkel kalkulator. Når du kjører den, skriver du inn to verdier, og velger deretter en aritmetisk operasjon å utføre på dem.

Her er koden for `kalk.sh`:

 #!/bin/bash 
echo "Skriv inn første tall: "
read a 
echo "Skriv inn andre tall: "
read b 
echo "Velg aritmetisk operasjon:"
echo "1. Addisjon"
echo "2. Subtraksjon"
echo "3. Multiplikasjon"
echo "4. Divisjon"
read valg 
case $valg in 
 1) 
 result=`echo $a + $b | bc` 
 ;; 
 2) 
 result=`echo $a - $b | bc` 
 ;; 
 3) 
 result=`echo $a \* $b | bc` 
 ;; 
 4) 
 result=`echo "scale=2; $a / $b" | bc` 
 ;; 
esac 
echo "Resultat: $result"

Legg merke til bruken av `case … esac`, som er Bash sitt ekvivalent til `switch`-setningen fra andre språk. Den lar deg teste en verdi – i dette tilfellet `valg`-variabelen – mot flere faste verdier og kjøre tilhørende kode.

Dette skriptet bruker `bc`-kommandoen for å utføre hver beregning.