Här är en utökad och mer avancerad version av artikeln om `bash(1)` i samma stil:

Praktisk användning av bash i Linux

Ingress

bash(1) (Bourne Again SHell) är en av de mest använda kommandotolkarna i Linux. Den används både interaktivt i terminalen och för att skriva skript som automatiserar uppgifter.

Denna artikel visar praktiska och verklighetsnära exempel på hur bash(1) används i olika situationer, från enkla kommandon till mer avancerad skriptning.

Hur bash fungerar

bash(1) tolkar kommandon som skrivs i terminalen eller i skriptfiler.

Starta en bash-session:

bash

Kör ett kommando direkt:

bash -c "echo Hej"

Variabler

Skapa en variabel:

namn="Martin"

Använd variabeln:

echo "Hej $namn"

Det går även att använda klamrar:

echo "Hej ${namn}"

Detta är särskilt användbart när variabler kombineras med annan text:

fil="${namn}.txt"

Villkor (if-satser)

if [ -f fil.txt ]; then
  echo "Filen finns"
fi

Vanliga tester:

`-f` – fil finns
`-d` – katalog finns
`-r` – filen är läsbar
`-w` – filen är skrivbar
`-x` – filen är körbar
`-z` – tom sträng
`-n` – strängen är inte tom

Exempel med else:

if [ -d backup ]; then
  echo "Katalogen finns"
else
  echo "Katalogen saknas"
fi

Loopar

For-loop:

for i in 1 2 3; do
  echo "Tal: $i"
done

While-loop:

while read rad; do
  echo "$rad"
done < fil.txt

Loop över filer:

for fil in *.txt; do
  echo "$fil"
done

Funktioner

hej() {
  echo "Hej $1"
}

hej Nisse

Funktioner kan också returnera statuskoder:

kontrollera_fil() {
  [ -f "$1" ]
}

if kontrollera_fil fil.txt; then
  echo "Filen finns"
fi

Argument till skript

#!/bin/bash
echo "Första argument: $1"
echo "Andra argument: $2"
echo "Antal argument: $#"

Kör:

./script.sh test exempel

Vanliga specialvariabler:

`$0` – skriptets namn
`$1`, `$2` – argument
`$#` – antal argument
`$@` – alla argument separat
`$*` – alla argument som en sträng
`$?` – senaste exit-koden
`$$` – aktuellt process-ID

Arbeta med filer

Kontrollera om fil finns:

[ -f fil.txt ] && echo "Finns"

Skapa fil:

touch fil.txt

Läsa rad för rad:

while IFS= read -r rad; do
  echo "$rad"
done < fil.txt

Detta är säkrare än enklare varianter eftersom det bättre bevarar mellanslag och bakåtsnedstreck.

Pipes och omdirigering

Skicka utdata till fil:

echo "Hej" > fil.txt

Lägg till i fil:

echo "igen" >> fil.txt

Skicka felutdata:

kommando 2> fel.log

Skicka både standardutdata och felutdata:

kommando > allt.log 2>&1

Använd pipe:

cat fil.txt | grep "Hej"

Praktiskt exempel: backup

#!/bin/bash
tar czf backup.tar.gz /home/martin

Praktiskt exempel: batch-körning

for fil in *.txt; do
  mv "$fil" "$fil.bak"
done

Praktiskt exempel: systeminformation

echo "Datum: $(date)"
echo "Användare: $(whoami)"
echo "Katalog: $(pwd)"

Avancerad användning

Kommandosubstitution

echo "Idag är $(date)"

Det går även att spara utdata i variabler:

datum=$(date +%F)
echo "$datum"

Villkor med flera tester

if [ -f fil.txt ] && [ -r fil.txt ]; then
  echo "Filen finns och är läsbar"
fi

Med dubbla hakparenteser:

if [[ -f fil.txt && -r fil.txt ]]; then
  echo "Filen finns och är läsbar"
fi

Exit-koder

Många Bash-skript bygger på att kommandon returnerar statuskoder.

if grep "fel" log.txt; then
  echo "Fel hittat"
else
  echo "Ingen träff"
fi

En exit-kod på `0` betyder normalt att kommandot lyckades.

Stränghantering

text="hej världen"
echo "${text^^}"
echo "${text,,}"

Ta bort prefix:

fil="rapport.txt"
echo "${fil%.txt}"

Byta ut text:

text="hej världen"
echo "${text/världen/Linux}"

Arrayer

Bash har stöd för arrayer:

frukter=("äpple" "banan" "päron")
echo "${frukter[0]}"
echo "${frukter[@]}"

Loop över array:

for frukt in "${frukter[@]}"; do
  echo "$frukt"
done

case-satser

När man vill hantera flera val är `case` ofta tydligare än många `if`-satser:

case "$1" in
  start)
    echo "Startar tjänsten"
    ;;
  stop)
    echo "Stoppar tjänsten"
    ;;
  restart)
    echo "Startar om tjänsten"
    ;;
  *)
    echo "Okänt kommando"
    ;;
esac

read och användarinmatning

Läs in data från användaren:

read -p "Ange namn: " namn
echo "Hej $namn"

Läs lösenord utan att visa tecken:

read -s -p "Lösenord: " losenord
echo

Arithmetic expansion

Bash kan göra enklare heltalsberäkningar:

a=5
b=3
echo $((a + b))
echo $((a * b))

I loopar:

for ((i=1; i<=5; i++)); do
  echo "$i"
done

Testa kommandon och felhantering

Kontrollera att ett kommando finns installerat:

if command -v curl >/dev/null 2>&1; then
  echo "curl finns installerat"
else
  echo "curl saknas"
fi

set -euo pipefail

I mer robusta skript används ofta:

set -euo pipefail

Detta innebär i korthet:

`-e` – avsluta om ett kommando misslyckas
`-u` – fel om odefinierad variabel används
`-o pipefail` – fånga fel även i pipelines

Exempel:

#!/bin/bash
set -euo pipefail

fil="data.txt"
grep "test" "$fil" | sort

Detta gör skript säkrare och lättare att felsöka.

trap

`trap` används för att fånga signaler eller städa upp innan skript avslutas.

trap 'echo "Avslutar..."; rm -f /tmp/minfil.$$' EXIT

Praktiskt exempel:

#!/bin/bash
tmpfil="/tmp/test.$$"
trap 'rm -f "$tmpfil"' EXIT

echo "temporär data" > "$tmpfil"
cat "$tmpfil"

Härdokument (heredoc)

Användbart för att skriva flera rader text:

cat <<EOF
Detta är rad 1
Detta är rad 2
EOF

Kan även användas för att skapa filer:

cat > config.txt <<EOF
namn=Martin
läge=test
EOF

Debuggning

För att se vad skriptet gör steg för steg:

bash -x script.sh

Eller inuti skriptet:

set -x

Stäng av igen:

set +x

Jobbkontroll och bakgrundskörning

Kör ett kommando i bakgrunden:

sleep 60 &

Visa jobb:

jobs

Flytta ett jobb till förgrunden:

fg

Subshells

Kommandon inom parentes körs i en subshell:

(cd /tmp && ls)

Detta påverkar inte aktuell katalog i det omgivande skriptet.

Processubstitution

Bash kan jämföra utdata från två kommandon direkt:

diff <(sort fil1.txt) <(sort fil2.txt)

Detta är mycket användbart i avancerad textbehandling.

Selektiv filmatchning

Bash kan använda mönster för filnamn:

echo *.txt

Med `shopt` kan funktioner utökas:

shopt -s nullglob

Det gör att tomma träffar inte returneras som bokstavlig text.

Associativa arrayer

I modern Bash finns stöd för nyckel/värde-par:

declare -A person
person[namn]="Martin"
person[stad]="Stockholm"

echo "${person[namn]}"

Mer robust hantering av argument

Loop över alla argument:

for arg in "$@"; do
  echo "Argument: $arg"
done

Detta är säkrare än att använda `$*` när argument kan innehålla mellanslag.

Praktiskt exempel: enkel meny

#!/bin/bash

while true; do
  echo "1) Visa datum"
  echo "2) Visa användare"
  echo "3) Avsluta"
  read -p "Val: " val

  case "$val" in
    1) date ;;
    2) whoami ;;
    3) break ;;
    *) echo "Ogiltigt val" ;;
  esac
done

Praktiskt exempel: säker loop över filer

#!/bin/bash
shopt -s nullglob

for fil in *.txt; do
  if [[ -f "$fil" ]]; then
    printf "Bearbetar %s\n" "$fil"
  fi
done

Praktiskt exempel: tillfällig arbetsfil

#!/bin/bash
set -euo pipefail

tmpfil=$(mktemp)
trap 'rm -f "$tmpfil"' EXIT

echo "Testdata" > "$tmpfil"
cat "$tmpfil"

Vanliga misstag i Bash

Vanliga fel i Bash-skript är:

att inte citera variabler, till exempel `"$fil"`
att använda `for rad in $(cat fil.txt)` för radvis läsning
att glömma kontrollera exit-koder
att använda `rm` tillsammans med osäkra globbar
att anta att filnamn aldrig innehåller mellanslag

Exempel på säkrare stil:

rm -- "$fil"

Skillnad mot sh

sh(1) är mer grundläggande, medan bash(1):

har stöd för arrayer
har fler inbyggda testmöjligheter
har bättre interaktiv funktionalitet
ger fler möjligheter för avancerad skriptning

Skript som måste vara strikt portabla mellan Unix-system skrivs ofta för `sh`, medan Bash ofta väljs på Linux när man vill ha mer funktionalitet.

När ska man använda bash?

bash(1) är särskilt användbart när man behöver:

automatisera uppgifter
skriva systemskript
hantera filer och textdata
bygga menyer och verktyg i terminalen
kombinera många Unix-kommandon effektivt

Sammanfattning

bash(1) är en central del av Linux-system och ett kraftfullt verktyg för både interaktivt arbete och skriptning. För enklare uppgifter räcker ofta grundläggande kommandon, men Bash erbjuder även avancerade funktioner som arrayer, `case`, `trap`, felsökning, robust felhantering och processubstitution. Det gör Bash till ett mycket viktigt verktyg för både utvecklare och systemadministratörer.

SE ÄVEN

bash(1), sh(1), zsh(1), printf(1), grep(1), sed(1), awk(1)

Sidslut

Det här är AI-genererat innehåll.

Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på: https://www.linux.se/kontakta-linux-se/

Besök vår systersida GeekToys.se där vi publicerar artiklar om datorer genom åren. Du hittar alla artiklar som finns på GeekToys på: https://geektoys.se/links/

Praktisk användning av bash i Linux

Praktisk användning av bash i Linux

Ingress

Hur bash fungerar

Variabler

Villkor (if-satser)

Loopar

Funktioner

Argument till skript

Arbeta med filer

Pipes och omdirigering

Praktiskt exempel: backup

Praktiskt exempel: batch-körning

Praktiskt exempel: systeminformation

Avancerad användning

Kommandosubstitution

Villkor med flera tester

Exit-koder

Stränghantering

Arrayer

case-satser

read och användarinmatning

Arithmetic expansion

Testa kommandon och felhantering

set -euo pipefail

trap

Härdokument (heredoc)

Debuggning

Jobbkontroll och bakgrundskörning

Subshells

Processubstitution

Selektiv filmatchning

Associativa arrayer

Mer robust hantering av argument

Praktiskt exempel: enkel meny

Praktiskt exempel: säker loop över filer

Praktiskt exempel: tillfällig arbetsfil

Vanliga misstag i Bash

Skillnad mot sh

När ska man använda bash?

Sammanfattning

SE ÄVEN

Sidslut

Navigeringsmeny

Sök