Admin: /* Funktioner */

2026-03-28T13:07:10Z

Funktioner

← Äldre version		Versionen från 28 mars 2026 kl. 13.07
Rad 108:		Rad 108:
	}		}

	hej ~~Martin~~		hej Nisse
	</pre>		</pre>

Admin: Skapade sidan med '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 avance...'

2026-03-28T11:54:02Z

Skapade sidan med '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 avance...'

Ny sida

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:

<pre>
bash
</pre>

Kör ett kommando direkt:

<pre>
bash -c "echo Hej"
</pre>

== Variabler ==
Skapa en variabel:

<pre>
namn="Martin"
</pre>

Använd variabeln:

<pre>
echo "Hej $namn"
</pre>

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

<pre>
echo "Hej ${namn}"
</pre>

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

<pre>
fil="${namn}.txt"
</pre>

== Villkor (if-satser) ==

<pre>
if [ -f fil.txt ]; then
echo "Filen finns"
fi
</pre>

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:

<pre>
if [ -d backup ]; then
echo "Katalogen finns"
else
echo "Katalogen saknas"
fi
</pre>

== Loopar ==
For-loop:

<pre>
for i in 1 2 3; do
echo "Tal: $i"
done
</pre>

While-loop:

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

Loop över filer:

<pre>
for fil in *.txt; do
echo "$fil"
done
</pre>

== Funktioner ==

<pre>
hej() {
echo "Hej $1"
}

hej Martin
</pre>

Funktioner kan också returnera statuskoder:

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

if kontrollera_fil fil.txt; then
echo "Filen finns"
fi
</pre>

== Argument till skript ==

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

Kör:

<pre>
./script.sh test exempel
</pre>

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:

<pre>
[ -f fil.txt ] && echo "Finns"
</pre>

Skapa fil:

<pre>
touch fil.txt
</pre>

Läsa rad för rad:

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

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

== Pipes och omdirigering ==
Skicka utdata till fil:

<pre>
echo "Hej" > fil.txt
</pre>

Lägg till i fil:

<pre>
echo "igen" >> fil.txt
</pre>

Skicka felutdata:

<pre>
kommando 2> fel.log
</pre>

Skicka både standardutdata och felutdata:

<pre>
kommando > allt.log 2>&1
</pre>

Använd pipe:

<pre>
cat fil.txt | grep "Hej"
</pre>

== Praktiskt exempel: backup ==

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

== Praktiskt exempel: batch-körning ==

<pre>
for fil in *.txt; do
mv "$fil" "$fil.bak"
done
</pre>

== Praktiskt exempel: systeminformation ==

<pre>
echo "Datum: $(date)"
echo "Användare: $(whoami)"
echo "Katalog: $(pwd)"
</pre>

== Avancerad användning ==

=== Kommandosubstitution ===

<pre>
echo "Idag är $(date)"
</pre>

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

<pre>
datum=$(date +%F)
echo "$datum"
</pre>

=== Villkor med flera tester ===

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

Med dubbla hakparenteser:

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

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

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

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

=== Stränghantering ===

<pre>
text="hej världen"
echo "${text^^}"
echo "${text,,}"
</pre>

Ta bort prefix:

<pre>
fil="rapport.txt"
echo "${fil%.txt}"
</pre>

Byta ut text:

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

=== Arrayer ===
Bash har stöd för arrayer:

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

Loop över array:

<pre>
for frukt in "${frukter[@]}"; do
echo "$frukt"
done
</pre>

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

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

=== read och användarinmatning ===
Läs in data från användaren:

<pre>
read -p "Ange namn: " namn
echo "Hej $namn"
</pre>

Läs lösenord utan att visa tecken:

<pre>
read -s -p "Lösenord: " losenord
echo
</pre>

=== Arithmetic expansion ===
Bash kan göra enklare heltalsberäkningar:

<pre>
a=5
b=3
echo $((a + b))
echo $((a * b))
</pre>

I loopar:

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

=== Testa kommandon och felhantering ===
Kontrollera att ett kommando finns installerat:

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

=== set -euo pipefail ===
I mer robusta skript används ofta:

<pre>
set -euo pipefail
</pre>

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:

<pre>
#!/bin/bash
set -euo pipefail

fil="data.txt"
grep "test" "$fil" | sort
</pre>

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.

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

Praktiskt exempel:

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

echo "temporär data" > "$tmpfil"
cat "$tmpfil"
</pre>

=== Härdokument (heredoc) ===
Användbart för att skriva flera rader text:

<pre>
cat <<EOF
Detta är rad 1
Detta är rad 2
EOF
</pre>

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

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

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

<pre>
bash -x script.sh
</pre>

Eller inuti skriptet:

<pre>
set -x
</pre>

Stäng av igen:

<pre>
set +x
</pre>

=== Jobbkontroll och bakgrundskörning ===
Kör ett kommando i bakgrunden:

<pre>
sleep 60 &
</pre>

Visa jobb:

<pre>
jobs
</pre>

Flytta ett jobb till förgrunden:

<pre>
fg
</pre>

=== Subshells ===
Kommandon inom parentes körs i en subshell:

<pre>
(cd /tmp && ls)
</pre>

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

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

<pre>
diff <(sort fil1.txt) <(sort fil2.txt)
</pre>

Detta är mycket användbart i avancerad textbehandling.

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

<pre>
echo *.txt
</pre>

Med `shopt` kan funktioner utökas:

<pre>
shopt -s nullglob
</pre>

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:

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

echo "${person[namn]}"
</pre>

=== Mer robust hantering av argument ===
Loop över alla argument:

<pre>
for arg in "$@"; do
echo "Argument: $arg"
done
</pre>

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

== Praktiskt exempel: enkel meny ==

<pre>
#!/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
</pre>

== Praktiskt exempel: säker loop över filer ==

<pre>
#!/bin/bash
shopt -s nullglob

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

== Praktiskt exempel: tillfällig arbetsfil ==

<pre>
#!/bin/bash
set -euo pipefail

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

echo "Testdata" > "$tmpfil"
cat "$tmpfil"
</pre>

== 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:

<pre>
rm -- "$fil"
</pre>

== 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 [https://geektoys.se GeekToys.se] där vi publicerar artiklar om datorer genom åren.
Du hittar alla artiklar som finns på GeekToys på:
https://geektoys.se/links/

[[Kategori:Linuxmanual grupp 1]]
[[Kategori:Linuxmanual]]
[[Kategori:Praktisk användning av kommandon]]

Praktisk användning av bash i Linux - Versionshistorik

Admin: /* Funktioner */