5 exempel på bashskript som hjälper dig att lära dig Linux-programmering

Innehållsförteckning

Bash-skript är ett populärt och lättillgängligt sätt att styra din Linux-dator genom programmering. Dessa enkla exempel på skript ger dig en inblick i processen och hjälper dig att lära dig grunderna i Bash-programmering.

2. Att visa ”Hello World” i Bash

Att skriva ut ”Hello World” är en klassisk introduktion till alla programmeringsspråk, och Bash är inget undantag.

Här är stegen för att visa ”Hello World” med Bash:

Öppna en texteditor och skapa en ny fil med följande kodrader.
Den första raden i ett Bash-skript ska alltid vara:
```
 #!/bin/bash 
```
Denna ”shebang” (#!/bin/bash) är viktig eftersom den talar om för systemet att skriptet ska tolkas av Bash. Det definierar vilken tolk som ska användas för att köra skriptet.
Rader som börjar med # är kommentarer. Shebang-raden är ett specialfall, men du kan lägga till egna kommentarer för att förklara koden. Lägg till en kommentar på rad 2, exempelvis:
```
 # Detta är en kommentar 
```
Kommandot `echo` används för att skriva ut till standardutgång. Lägg till följande på rad 3:
```
 echo "Hello World" 
```
Spara filen, gärna med filändelsen .sh, till exempel hello_world.sh. Filändelsen är inte obligatorisk, men det är en god konvention.
För att köra skriptet måste filen göras körbar. Använd kommandot `chmod` (change mode) med argumentet +x (körbar) och namnet på ditt skript:
```
 chmod +x hello_world.sh 
```
Kör skriptet från dess katalog med kommandot:
```
 ./hello_world.sh 
```
När skriptet körs kommer det att visa ”Hello World” i terminalen:

3. Skapa en katalog genom att läsa inmatning

Du kan köra alla kommandon som du normalt använder i terminalen direkt från dina skript. Till exempel kan du skapa en ny katalog med kommandot `mkdir`.

Börja med shebang-raden som tidigare:
```
 #!/bin/bash 
```
Be användaren ange ett katalognamn med `echo`:
```
 echo "Ange namnet på en ny katalog:" 
```
Använd kommandot `read` för att läsa in användarinmatningen. Argumentet namnger en variabel där indata lagras:
```
 read newdir 
```
För att använda värdet i en variabel, skriv ett dollartecken ($) framför variabelnamnet. Använd variabeln som argument till `mkdir` för att skapa katalogen:
```
 mkdir $newdir 
```
När du kör skriptet kommer du att bli ombedd att skriva in ett namn. Ange ett giltigt katalognamn så kommer skriptet att skapa den i den aktuella katalogen.

4. Skapa en katalog med kommandoradsargument

De flesta Linux-kommandon kan ta emot argument som du kan använda för att anpassa deras beteende. Du kan ange argument när du kör ett program.

I ditt skript kan du referera till det första argumentet med `$1`, det andra med `$2`, och så vidare.

Använd kommandot `mkdir` från föregående exempel, men använd den inbyggda variabeln `$1`:
```
 #!/bin/bash
mkdir $1 
```
Kör skriptet och skicka ett nytt katalognamn som ett argument:
```
 ./arg_dir.sh Test 
```

Vad händer om du kör skriptet utan att ange något argument? Prova så ser du att du får ett felmeddelande som börjar med ”användning: mkdir”:

Utan kommandoradsargument blir `$1` tomt. När skriptet anropar `mkdir` utan argument returneras ett fel. För att undvika detta kan du göra en egen kontroll och ge ett mer användarvänligt felmeddelande:

Börja som alltid med shebang-raden:
```
 #!/bin/bash 
```
Kontrollera om det första argumentet är tomt innan du anropar `mkdir`. Använd Bashs `if`-sats för att köra kod beroende på ett villkor:
```
 if [ -z "$1" ]; then 
```
Om det första argumentet är tomt, skriv ut ett felmeddelande och avsluta skriptet:
```
    echo "Du måste ange ett katalognamn som första argument"
    exit 
```
Nyckelordet ”fi” avslutar if-satsen i Bash:
```
 fi 
```
Skriptet kan nu fortsätta som tidigare för att skapa en katalog om ett argument har angetts:
```
 mkdir $1 
```

Om du kör den här nya versionen och glömmer att ange argument, får du ett meddelande:

5. Ta bort en fil med en Bash-funktion

Om du märker att du upprepar samma kod, bör du överväga att kapsla in den i en funktion. Du kan sedan anropa funktionen när du behöver den.

Här är ett exempel på en funktion som tar bort en angiven fil.

Börja med shebang-raden:
```
 #!/bin/bash 
```
Definiera en funktion genom att skriva dess namn, följt av tomma parenteser och kommandon inom klamrar:
```
 del_file() {
    echo "Tar bort $1"
    rm $1
} 
```
Du kan sedan anropa funktionen och ange namnet på filen som ska tas bort:
```
 del_file test.txt 
```

När du anropar en funktion lagras utgångsstatusen för det senaste kommandot i `$?`. Utgångsstatusen används för felkontroll; du kan till exempel testa om `rm` lyckades:

 if [ $? -ne 0 ]; then
    echo "Kunde inte ta bort filen"
fi

6. Skapa en enkel kalkylator för aritmetiska beräkningar

Det här sista exemplet visar hur man skapar en mycket enkel kalkylator. När du kör den anger du två värden och väljer sedan en aritmetisk operation.

Här är koden för calc.sh:

 #!/bin/bash
echo "Ange första talet: "
read a
echo "Ange andra talet: "
read b 

echo "Välj aritmetisk operation:"
echo "1. Addition"
echo "2. Subtraktion"
echo "3. Multiplikation"
echo "4. Division"
read choice 

case $choice 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"

Observera användningen av `case … esac`, som är Bashs motsvarighet till `switch`-satsen i andra språk. Den låter dig testa ett värde – i det här fallet variabeln `choice` – mot flera fasta värden och köra relaterad kod.

Detta skript använder kommandot `bc` för att utföra beräkningarna.