Grundlagen der Shellskripterstellung

Ein Shellskript speichert eine Befehlsfolge in einer reinen Textdatei. Bash liest die Befehle der Reihe nach, genau wie die Befehle, die du an einer Eingabeaufforderung eingibst. Ein Skript kann eine Aufgabe wiederholen, ohne dass jemand jeden Schritt eintippt, und bietet dir eine zentrale Stelle, um die Aufgabe zu korrigieren oder zu verbessern.

Den Interpreter in die erste Zeile setzen

Der Shebang teilt Linux mit, welches Programm ein ausführbares Skript lesen soll. Beginne ein Bash-Skript mit #!/bin/bash. Die Zeichen #! müssen die ersten beiden Zeichen der Datei sein: Davor dürfen keine Leerzeichen und keine Leerzeile stehen. Bash steht für Bourne Again Shell. Sie wird unter Linux häufig als interaktive Shell genutzt und liest auch Skriptdateien.

Ein Interpreter ist ein Programm, das eine andere Sprache liest und ausführt. Derselbe Mechanismus ermöglicht es, mit #!/usr/bin/python3 Python oder mit #!/usr/bin/awk -f awk auszuwählen. Der Rest eines Bash-Skripts muss Shellbefehle enthalten, die Bash versteht.

Erstelle backup-notes.sh in einem Editor für reinen Text wie nano oder vi:

#!/bin/bash
# Keep a copy of the notes and show the backup folder.
mkdir -p ~/backup
cp ~/notes.txt ~/backup/
ls -l ~/backup

Bash legt zuerst das Zielverzeichnis an, kopiert dann die Notizen und listet anschließend das Ziel auf. mkdir -p ist auch erfolgreich, wenn das Verzeichnis bereits existiert, sodass ein späterer Lauf es wiederverwenden kann. Die Quelldatei ~/notes.txt muss existieren, damit das Kopieren funktioniert. Durch das Speichern der Befehle wird diese Quelldatei nicht angelegt.

Die Datei für Menschen lesbar machen

Die zweite Zeile ist ein Kommentar. Außerhalb von durch Quoting geschütztem Text beginnt # am Anfang eines Wortes einen Kommentar; Bash ignoriert den Rest der Zeile. Beschreibe in Kommentaren den Zweck eines Schrittes, etwa warum eine Sicherung aufbewahrt werden muss. Leerzeilen und Einrückungen machen Befehlsgruppen leichter erkennbar. Rücke einheitlich ein, wenn du Bedingungen und Schleifen hinzufügst.

Die Endung .sh hilft beim Erkennen eines Shellskripts. Linux verlangt diese Endung nicht, und sie wählt weder Bash aus noch erteilt sie Ausführungsrecht. Eine Datei namens backup-notes kann dieselben Befehle ausführen.

Die Shell passend zur Sprache wählen

Unter Debian und Ubuntu wählt /bin/sh normalerweise dash aus. Bash-Funktionen wie [[ ... ]] schlagen dort fehl. Ein Bash-Skript braucht einen Bash-Interpreter, auch wenn einfache Befehle zufällig unter beiden Shells funktionieren. Der Dateiname something.sh behebt keinen unpassenden Shebang.

Ein Problem mit Zeilenenden erkennen

Windows-Editoren können vor jedem Zeilenvorschub einen Wagenrücklauf speichern. Unter Linux kann dieses unsichtbare Zeichen Teil des Shebang-Pfads werden. Ein Fehler wie /bin/bash^M: bad interpreter: No such file or directory weist auf dieses Problem hin, obwohl /bin/bash existiert.

Wandle die Datei mit dos2unix backup-notes.sh in Unix-Zeilenenden um und speichere künftige Skripte im Editor mit Unix-Zeilenenden. Die Befehle in der Datei können korrekt sein, während das zusätzliche Zeichen Linux daran hindert, ihren Interpreter zu starten.

Bash kann ein Skript direkt lesen oder es kann als Programm gestartet werden. Diese Wege unterscheiden sich darin, welche Rechte sie benötigen und wie der Interpreter gewählt wird. Der eingegebene Pfad bestimmt außerdem, ob die Shell nach einem Befehl sucht oder eine bestimmte Datei verwendet.

Zwei Wege, dieselbe Datei zu starten

bash backup-notes.sh
chmod u+x backup-notes.sh
./backup-notes.sh

Der erste Befehl startet Bash und lässt sie die Datei lesen. Das Skript braucht Leserecht; sein eigenes Ausführungsbit ist nicht nötig. Bash behandelt den Shebang als Kommentar, weil der Interpreter bereits gewählt wurde.

Der zweite Befehl fügt für den Eigentümer der Datei Ausführungsrecht hinzu. In einer Rechtezeichenfolge wie -rwxr--r-- bedeutet das x des Eigentümers, dass die Datei ausführbar ist. Der dritte Befehl führt die Datei als Programm aus und verwendet ihren Shebang. Auch chmod +x ist gebräuchlich; ohne eine angegebene Berechtigungsklasse begrenzt die umask, welche Klassen Ausführungsrecht erhalten. chmod u+x richtet sich ausdrücklich an den Eigentümer.

Meldet ./backup-notes.sh „Permission denied“, prüfe das Ausführungsrecht und den Zugriff auf den Pfad. Wenn bash backup-notes.sh funktioniert, heißt das nicht, dass die nötigen Rechte für die direkte Ausführung vorliegen.

Die Befehlssuche verstehen

./ bedeutet das aktuelle Verzeichnis. Enthält ein Befehl einen Schrägstrich, folgt Bash diesem Pfad. Gibst du einen Namen ohne Schrägstrich ein, durchsucht Bash die Verzeichnisse in PATH. Das aktuelle Verzeichnis fehlt normalerweise in dieser Liste. Es reicht also nicht, im Verzeichnis eines Skripts zu sein, um es allein über seinen Namen auszuführen.

echo "$PATH"
command -v backup-notes.sh
type backup-notes.sh

PATH ist eine durch Doppelpunkte getrennte Liste, zum Beispiel /home/sam/.local/bin:/usr/local/bin:/usr/bin:/bin. Die erste passende ausführbare Datei wird verwendet. Die letzten beiden Befehle helfen zu erkennen, was bei einem Namen ausgeführt wird, auch wenn es sich um eine ältere Kopie an einer anderen Stelle auf dem PATH handelt.

Um ein persönliches Skript über seinen Namen verfügbar zu machen, lege es in einem Verzeichnis auf deinem PATH ab. Viele Distributionen fügen ~/bin oder ~/.local/bin bei der Anmeldung hinzu, wenn das Verzeichnis existiert; prüfe deinen tatsächlichen PATH. /usr/local/bin ist ein üblicher Speicherort für gemeinsam genutzte Skripte. Zum Schreiben dort sind Administratorrechte nötig.

Zwischen einer Kind-Shell und der aktuellen Shell wählen

./settings.sh oder bash settings.sh startet einen Bash-Kindprozess. Dessen Variablen und Verzeichniswechsel gehören zu diesem Kindprozess. Ein Skript mit cd /var/log ändert das Verzeichnis des Terminals nicht, von dem aus es gestartet wurde. Wenn es endet, befindest du dich im Terminal weiterhin im bisherigen Verzeichnis.

Beim Sourcing werden Befehle in die aktuelle Shell eingelesen:

source ./settings.sh
# Equivalent short form:
. ./settings.sh

Nutze dies für eine Einstellungsdatei, die deine Sitzung ändern soll. Sourcing benötigt Lese-, aber kein Ausführungsrecht, und ein Shebang startet keinen separaten Interpreter. Das Einlesen einer Bash-Einstellungsdatei setzt daher voraus, dass die aktuelle Shell Bash-Syntax versteht.

Das Ergebnis eines Laufs lesen

Unmittelbar nach dem Ende eines Skripts zeigt echo $? dessen Rückgabestatus. Sofern das Skript nicht exit mit einem gewählten Code verwendet, stammt sein Status vom letzten Befehl. Eine erfolgreiche abschließende Auflistung kann daher einen zuvor fehlgeschlagenen Kopiervorgang verbergen; spätere Fehlerprüfungen ermöglichen es dem Skript, das tatsächliche Ergebnis der Aufgabe zu melden.

Eine Variable gibt einem Wert einen Namen, damit dasselbe Skript ihn wiederverwenden kann. Bash-Variablen enthalten normalerweise Text, auch wenn dieser wie eine Zahl aussieht. Du weist den Wert einmal zu und expandierst den Namen überall dort, wo ein Befehl diesen Wert benötigt.

Ohne Leerzeichen zuweisen

city=Lisbon
greeting="Good morning"
echo "$greeting from $city"

Die Ausgabe lautet „Good morning from Lisbon“. Um das Zuweisungszeichen = stehen keine Leerzeichen. Bei city = Lisbon behandelt Bash city als Befehl und die anderen Wörter als Argumente. Die Anführungszeichen um "Good morning" halten beide Wörter in einem Wert zusammen.

Verwende Buchstaben, Ziffern und Unterstriche in Variablennamen und beginne mit einem Buchstaben oder Unterstrich. Groß- und Kleinschreibung wird unterschieden: file, File und FILE sind verschieden. Wähle für skripteigene Werte kleingeschriebene Namen wie backup_dir. Das hilft zu vermeiden, dass Umgebungsvariablen wie PATH oder HOME überschrieben werden. Das Setzen von PATH=/data ändert die Befehlsauflösung und kann dazu führen, dass gewöhnliche Befehle nicht mehr gefunden werden.

Das Ende eines Namens markieren

Ein Dollarzeichen leitet eine Expansion ein. Geschweifte Klammern zeigen die Grenze, wenn unmittelbar weiterer Text folgt:

file=report
echo "${file}_old"

Dies gibt „report_old“ aus. Bei "$file_old" sucht Bash nach einer Variable namens file_old, nicht nach file gefolgt von _old. Ohne set -u wird ein nicht gesetzter Name zu leerem Text expandiert. Ein Schreibfehler kann daher einen leeren Pfad oder eine leere Meldung erzeugen, ohne sofort einen Fehler auszulösen.

Ein Wert wie count=5 speichert den Text „5“. Text neben einer Expansion bewirkt keine Berechnung: echo "$count+1" gibt „5+1“ aus. Die arithmetische Expansion gibt Zahlen eine andere Rolle, wenn Berechnungen nötig sind.

Eine Eingabezeile lesen

read -r -p "Your name: " name
echo "Hello, $name"

read speichert die eingegebene Zeile in name. -p gibt die Eingabeaufforderung vor und -r erhält Backslashes. Bei der Eingabe „Lee Kim“ lautet die Begrüßung „Hello, Lee Kim“. Ein Skript, das ohne anwesende Person läuft, benötigt seine Eingaben aus Argumenten, Dateien oder Standardwerten; eine Eingabeaufforderung kann einen fehlenden Wert nicht zuverlässig liefern.

Werte für Kindprozesse exportieren

Eine gewöhnliche Shellvariable gehört zu der Shell, in der sie gesetzt wurde. Durch Exportieren wird sie für die Aufnahme in die Umgebung markiert, die an die von dieser Shell gestarteten Programme kopiert wird:

export BACKUP_DIR=/mnt/usb
bash backup-notes.sh

Die Bash im Kindprozess kann nun BACKUP_DIR lesen. Weist der Kindprozess einen anderen Wert zu, behält der Elternprozess seinen eigenen Wert. Die Umgebung wird vom Eltern- an den Kindprozess vererbt; spätere Änderungen werden nicht zurückgesendet.

env oder printenv zeigt Umgebungsvariablen an. unset name entfernt die Variable namens name; es weist keine leere Zeichenkette zu. Bei normaler Expansion können beide leer erscheinen, aber eine Prüfung auf nicht gesetzte Variablen kann eine fehlende von einer gesetzten Variable unterscheiden.

Bash liest einen Befehl, bevor das Programm seine Argumente erhält. Leerzeichen trennen Wörter und Zeichen wie *, ?, $, ;, &, |, < und > haben besondere Funktionen. Quoting steuert, welche dieser Funktionen aktiv bleiben.

Wählen, was expandiert werden soll

Vergleiche bei HOME=/home/sam:

echo 'Home: $HOME *'
echo "Home: \$HOME *"

Der erste Befehl gibt „Home: $HOME *“ aus. Der zweite gibt ebenfalls „Home: $HOME *“ aus. Das Sternchen bleibt in beiden Fällen wörtlich erhalten. Doppelte Anführungszeichen erlauben zwar die Expansion der Variable, aber der Backslash verhindert sie hier. Ein einfaches Anführungszeichen kann nicht unmittelbar innerhalb einer Zeichenkette in einfachen Anführungszeichen stehen.

Innerhalb doppelter Anführungszeichen können Backslashes ein Dollarzeichen, einen Backtick, ein doppeltes Anführungszeichen oder einen Backslash schützen. Zum Beispiel gibt echo "Price: \$5" die Ausgabe „Price: $5“ aus. Außerhalb von Anführungszeichen gibt echo 5 \* 3 die Ausgabe „5 * 3“ aus und touch my\ file.txt legt eine Datei mit einem Leerzeichen im Namen an.

Einen Wert ohne Quoting durch Bash verfolgen

file="my report.txt"
cp $file backup/

Zuerst expandiert Bash die Variable. Dann teilt die Wortaufteilung ihren Wert an Leerzeichen, Tabulatoren und Zeilenvorschüben. Der Befehl erhält my, report.txt und backup/ als separate Argumente. Er versucht, zwei Quelldateien statt der einen beabsichtigten Datei zu kopieren.

Enthält ein entstandenes Wort Platzhalterzeichen, ersetzt die Dateinamenexpansion es anschließend durch passende Dateinamen. Ein gespeicherter Wert *.txt kann bei einer Expansion ohne Quoting zu mehreren Dateiargumenten werden. Diese zusätzlichen Schritte erfolgen, bevor cp startet; das Programm kann die beabsichtigte Gruppierung nicht wiederherstellen.

cp "$file" backup/

Nun bleibt der expandierte Wert ein Argument: „my report.txt“. Bash entfernt die Anführungszeichen selbst; sie sind Anweisungen für die Auswertung und kein Teil des an cp übergebenen Pfads. Setze Variablenexpansionen und Befehlssubstitutionen in doppelte Anführungszeichen, wenn ihr vollständiger Wert zusammenbleiben soll.

Einen leeren Wert erhalten

Quoting ist auch wichtig, wenn ein Wert leer ist. In [ $answer = yes ] verschwindet ein leeres answer und hinterlässt einen ungültigen Test. [ "$answer" = yes ] übergibt eine leere Zeichenkette als ein Argument, sodass der Test gültig und falsch ist.

Dieselbe Gruppierungsregel gilt für wörtlich angegebene Wörter. mkdir new folder legt zwei Verzeichnisse an, während mkdir "new folder" eines anlegt. Das Quoting eines gesamten Pfads ist nützlich, unabhängig davon, ob sein Leerzeichen direkt eingegeben wurde oder aus einer Variable stammt.

Wörtlichen und expandierten Text verbinden

Benachbarte Teile in Anführungszeichen bilden ein Wort, wenn kein Leerzeichen sie trennt. Bei price=8 gibt echo 'Price: $'"$price" die Ausgabe „Price: $8“ aus. Der feste Teil steht in einfachen und der veränderliche Teil in doppelten Anführungszeichen. Ebenso lässt sich ein Suchmuster festhalten: grep 'cost: \$[0-9]' prices.txt übergibt sein Muster ohne Shell-Expansion, sodass grep das Muster interpretieren kann.

Befehle erzeugen häufig einen Wert, den ein anderer Schritt benötigt. Bash kann diese Ausgabe erfassen, in Text einsetzen oder für eine Berechnung verwenden. Befehlssubstitution und arithmetische Expansion haben ähnliche Satzzeichen, erfüllen aber unterschiedliche Aufgaben.

Die Standardausgabe erfassen

today=$(date +%F)
cp notes.txt "notes-${today}.txt"

$(...) führt einen Befehl aus und ersetzt die Substitution durch dessen Standardausgabe. Am 2026-10-22 enthält today „2026-10-22“ und die Kopie heißt notes-2026-10-22.txt. Ein Datum in der Reihenfolge Jahr-Monat-Tag hält Dateinamen bei der Sortierung nach Namen in Datumsreihenfolge. Du kannst die Substitution auch direkt in den Namen setzen: "notes-$(date +%F).txt".

Zeilenvorschübe am Ende der erfassten Ausgabe werden entfernt. Auch die ältere Form mit Backticks erfasst Ausgaben, aber $(...) lässt sich leichter lesen und verschachteln. Setze eine als Befehlsargument verwendete Substitution wie "$(date +%F)" in doppelte Anführungszeichen, damit ihr Ergebnis zusammenbleibt.

Die Befehlssubstitution erfasst nur die Standardausgabe. Fehler auf der Standardfehlerausgabe gehen weiterhin an ihr übliches Ziel. result=$(some_command 2>&1) führt beide Ströme innerhalb der Erfassung zusammen, wenn das Skript dies benötigt. Würden Fehler mit einem Wert vermischt, der eine Zahl enthalten soll, schlüge eine spätere Berechnung fehl.

Eine Anzahl ohne Dateinamen erfassen

lines=$(wc -l < access.log)
echo "Lines: $lines"

Enthält die Datei 342 Zeilenvorschübe, liefert wc die Anzahl 342. Wird die Datei in wc umgeleitet, enthält dessen Ausgabe nur die Anzahl; wc -l access.log gibt außerdem den Dateinamen aus. Ein Ergebnis, das wie eine Zahl aussieht, kann anschließend wiederverwendet werden, sofern der Befehl erfolgreich war.

Mit ganzen Zahlen rechnen

$(( ... )) führt eine arithmetische Expansion aus:

echo "$(( 17 / 5 ))"
echo "$(( 17 % 5 ))"

Die Ergebnisse sind 3 und 2. Die Ganzzahldivision lässt den Rest entfallen; % liefert ihn. Für Addition, Subtraktion und Multiplikation werden +, - und * verwendet. Variablennamen können innerhalb des Ausdrucks ohne Dollarzeichen stehen: total=$(( price * qty )).

Bei a=5 gibt echo "$a+3" den Text „5+3“ aus. echo "$(( a + 3 ))" berechnet das Ergebnis und gibt 8 aus. Die zusätzlichen Klammern wählen die Arithmetik; $(a + 3) würde stattdessen versuchen, einen Befehl namens a auszuführen.

Ein Zähler beginnt mit einem Wert wie count=0 und wird mit count=$(( count + 1 )) aktualisiert. Bash bietet auch (( count++ )); dies ist ein arithmetischer Befehl mit eigenem Rückgabestatus, was in Skripten mit Fehleroptionen wichtig ist.

Die benötigte Genauigkeit erhalten

Die Bash-Arithmetik verwendet ganze Zahlen. 7 / 2 ergibt 3 und ein Dezimalwert wie 2.5 verursacht einen arithmetischen Syntaxfehler. Ein separates Werkzeug kann mit Dezimalzahlen rechnen:

echo "scale=2; 7 / 2" | bc

Dies ergibt 3.50. Multipliziere bei der Ganzzahlarithmetik vor dem Dividieren, wenn das Produkt einen noch benötigten Bruchteil erhält. Für 45 von 60 ergibt $(( 45 * 100 / 60 )) den Wert 75. Wird zuerst dividiert, ergibt 45 / 60 null, sodass $(( 45 / 60 * 100 )) null bleibt; der verlorene Bruchteil lässt sich durch spätere Multiplikation nicht zurückgewinnen.

Ein Befehl meldet sein Ergebnis auf zwei Arten: Er kann Text ausgeben und liefert einen Rückgabestatus. Programme entscheiden anhand dieses Status, was als Nächstes geschieht. Ein Skript kann eine beruhigende Meldung ausgeben und dennoch fehlgeschlagen sein oder nichts ausgeben und erfolgreich sein.

Einen Status lesen, bevor er sich ändert

Ein Rückgabestatus ist eine ganze Zahl von 0 bis 255. Null bedeutet Erfolg. Ein Wert ungleich null meldet einen Fehlschlag oder ein anderes dokumentiertes Ergebnis. grep verwendet zum Beispiel 0 für einen Treffer, 1 für keinen Treffer und 2 für einen Fehler. Eine Suche ohne Treffer kann für deine Aufgabe ein normales Ergebnis sein, obwohl ihr Status ungleich null ist.

$? enthält den Status des zuletzt ausgeführten Befehls:

grep -q root /etc/passwd
status=$?
echo "Search status: $status"

Die Zuweisung speichert das Ergebnis, bevor ein anderer Befehl es ersetzt. Bei ls /missing; echo $?; echo $? liefert GNU ls den Wert 2 für den unzugänglichen Befehlszeilenpfad. Das erste echo gibt 2 aus und ist dann erfolgreich. Das zweite gibt 0 aus, den Status dieses echo und nicht den der ursprünglichen Auflistung.

Mit einem nützlichen Ergebnis enden

exit 1 beendet ein Skript sofort und meldet seinem Aufrufer 1. exit 0 meldet Erfolg. Ein exit ohne Zahl verwendet den Status des vorherigen Befehls; wird das Ende normal erreicht, gilt der Status des letzten Befehls. Wähle Codes zwischen 0 und 255: exit 256 läuft auf 0 um und würde fälschlich Erfolg melden.

Einige Statuswerte stammen von Bash selbst:

Strg+C sendet Signal 2, daher meldet ein so beendeter Befehl üblicherweise 130. Auch gewöhnliche Programme dokumentieren ihre eigenen Codes; 1 und 2 haben nicht in allen Werkzeugen eine einheitliche Bedeutung.

Abhängige Befehle verketten

mkdir -p ~/backup && cp notes.txt ~/backup/
cd /data/reports || exit 1

&& führt den nächsten Befehl nur nach Erfolg aus. Hier hängt das Kopieren davon ab, dass das Sicherungsverzeichnis erstellt oder gefunden wird. || führt den nächsten Befehl nur nach einem Fehlschlag aus. Hier beendet ein fehlgeschlagener Verzeichniswechsel das Skript, bevor spätere Befehle das falsche Arbeitsverzeichnis verwenden.

true liefert 0; false liefert 1. Ein vorangestelltes ! kehrt Erfolg oder Fehlschlag eines Befehls um. ! grep -q ERROR app.log ist erfolgreich, wenn die Suche keine passende Zeile findet, allerdings auch, wenn grep mit einem Fehler fehlschlägt. Verwende ausdrückliche Statusprüfungen, wenn diese Ergebnisse unterschieden werden müssen.

Eine ganze Pipeline prüfen

grep ERROR missing.log | wc -l

Standardmäßig hat eine Pipeline den Status ihres letzten Befehls. grep schlägt wegen der fehlenden Datei fehl, aber wc liest einen leeren Strom, gibt 0 aus und ist erfolgreich. Der Status der Pipeline ist daher 0.

set -o pipefail lässt eine Pipeline fehlschlagen, wenn einer ihrer Befehle fehlschlägt. Sie meldet den Status ungleich null, der am weitesten rechts steht, oder 0, wenn alle Befehle erfolgreich sind. Dadurch werden Fehler früherer Befehle für if, &&, || und den Aufrufer sichtbar. Ein Zeitplaner kann dann einen erfolgreichen Bericht von einem unterscheiden, der seine Eingabe nie gelesen hat.

Bash läuft normalerweise weiter, nachdem ein Befehl fehlgeschlagen ist. Hängt der nächste Befehl von dieser Arbeit ab, kann aus einem kleinen Fehler durch das Fortfahren ein größeres Problem werden. Prüfe abhängige Schritte ausdrücklich und finde anschließend mit Syntaxprüfung und Ablaufverfolgung heraus, warum ein Lauf anders als geplant verläuft.

Anhalten, bevor sich ein Fehler auswirkt

cd /backups || exit 1

Nun können die nachfolgenden Befehle nur nach einem erfolgreichen Verzeichniswechsel ausgeführt werden. Das ist vor Dateioperationen wichtig: Schlägt ein Verzeichniswechsel fehl und läuft das Skript weiter, beziehen sich relative Pfade weiterhin auf das alte Verzeichnis. Prüfe das Ziel, bevor du Befehle ausführst, die Dateien ändern oder löschen.

Eine Fehlermeldung und ein Fehlerstatus richten sich an unterschiedliche Empfänger:

echo "Error: $file not found" >&2
exit 1

Die Meldung geht an die Standardfehlerausgabe, sodass die Standardausgabe für Daten verfügbar bleibt. Bei ./report.sh > report.txt bleibt die Meldung im Terminal sichtbar, während die normale Ausgabe in die Datei gelangt. Der Status ungleich null ermöglicht einem anderen Programm, den Fehler zu erkennen, ohne den Satz zu lesen.

Syntax prüfen und dann den Ablauf verfolgen

Ein fehlendes fi, done oder schließendes Anführungszeichen ist ein Syntaxproblem. bash -n kann es finden, oft anhand einer Meldung wie „unexpected end of file“. Ein syntaktisch gültiger, aber falsch geschriebener Dateipfad muss bei der Ausführung geprüft werden.

Bei der Ablaufverfolgung wird Befehlen ein + vorangestellt. Eine Zeile wie cp "$src" "$dest" zeigt dabei die tatsächlich eingesetzten Pfade. set -x und set +x schalten die Ablaufverfolgung für einen Abschnitt ein und wieder aus.

Die Fehleroptionen verstehen

set -euo pipefail kombiniert drei Einstellungen:

• -e beendet das Skript nach einem nicht behandelten Fehlschlag eines Befehls.
• -u meldet eine nicht gesetzte Variable als Fehler.
• pipefail sorgt dafür, dass sich fehlgeschlagene Pipeline-Befehle auf den Pipeline-Rückgabestatus auswirken.

-e lässt erwartete Fehlschläge in if-, while- und until-Bedingungen, bei negierten Befehlen und bei nicht letzten Befehlen in &&- oder ||-Listen zu. Ohne pipefail löst ein Fehlschlag vor dem letzten Pipeline-Befehl kein Beenden aus. Ausdrückliche Prüfungen bleiben nützlich, weil sie festlegen, was das Skript beim Fehlschlag eines bestimmten Schrittes tun soll.

Auch ein arithmetischer Befehl meldet wahr oder falsch. (( count++ )) liefert Status 1, wenn der alte Wert 0 ist. Eine nicht behandelte Verwendung unter -e kann das Skript daher stoppen, obwohl die Erhöhung stattgefunden hat. Die Zuweisung count=$(( count + 1 )) vermeidet diesen Status des arithmetischen Befehls.

-u fängt einen Tippfehler wie $filname ab, wenn nur filename gesetzt wurde. Eine Variable, die existiert, aber leer ist, wird nicht zurückgewiesen. ${dir:?not set} prüft bei dieser Expansion, ob dir fehlt oder leer ist. Ein erwartetes Ergebnis ohne Treffer lässt sich mit einem Test behandeln; command || true unterdrückt jeden Fehlschlag dieses Befehls. Verwende es daher nur, wenn alle diese Fehlschläge akzeptabel sind.

Meldungen lesen und aufräumen

„Command not found“ weist auf ein Problem mit einem Namen, einem installierten Programm oder PATH hin. „Permission denied“ weist auf ein Problem beim Ausführen oder Dateizugriff hin. „Unary operator expected“ entsteht häufig durch einen leeren Wert ohne Quoting in [ ]; „integer expression expected“ bedeutet, dass eine numerische Prüfung Text erhalten hat.

Ein EXIT-Trap richtet eine Aufräumaktion ein, zum Beispiel trap 'rm -f "$tmpfile"' EXIT, nachdem tmpfile ein Wert zugewiesen wurde. Der Befehl in Anführungszeichen läuft, wenn Bash endet, auch bei einem ausdrücklichen exit oder einem Fehlerabbruch unter -e. ShellCheck kann Skripte vor einem Lauf ebenfalls auf häufige Quoting- und Logikfehler prüfen.

Eine Bedingung in Bash ist ein Befehl, dessen Status wahr oder falsch bedeutet. Mit Tests kannst du Fragen zu Pfaden, Text und Zahlen stellen. Wähle einen Operator passend zur Art des Werts; dieselben ausgegebenen Zeichen können als Text und als Zahl unterschiedliche Bedeutungen haben.

Dem Test eigene Wörter geben

test -f notes.txt und [ -f notes.txt ] fragen, ob ein Pfad auf eine existierende reguläre Datei verweist. [ ist ein Befehl und sein letztes Argument muss ] sein. Leerzeichen trennen seine Argumente:

[ -f "$file" ]

Ohne das Leerzeichen nach [ sucht Bash möglicherweise nach einem Befehl namens [-f. In [ "$a"="$b" ] bilden die fehlenden Leerzeichen um = ein nicht leeres Wort. Der Test ist daher wahr, selbst wenn sich die Werte unterscheiden. Operatoren müssen separate Argumente sein.

Eine Dateiprüfung wählen

Bei einem Verzeichnis namens logs sind -e und -d erfolgreich, während -f fehlschlägt. Dateiprüfungen folgen einem symbolischen Link normalerweise bis zu seinem Ziel; -L prüft den Link selbst. Ein toter Link kann daher -L erfüllen und bei -e fehlschlagen.

Text oder ganze Zahlen vergleichen

Zeichenkettenprüfungen verwenden = und != für Gleichheit und Ungleichheit. -z prüft auf die Länge null und -n auf eine Länge ungleich null. [ "$answer" = yes ] trifft genau auf „yes“ zu; „Yes“ und „yes “ sind anderer Text. Doppelte Anführungszeichen erhalten einen leeren Wert im Test.

Ganzzahlvergleiche verwenden -eq, -ne, -lt, -le, -gt und -ge: gleich, ungleich, kleiner als, kleiner oder gleich, größer als und größer oder gleich. [ "$count" -gt 100 ] fragt, ob die Zahl 100 übersteigt.

[ 07 -eq 7 ]
[ 07 = 7 ]

Der numerische Vergleich ist erfolgreich, weil die Werte gleich sind. Der Zeichenkettenvergleich schlägt fehl, weil ein Text mit einer zusätzlichen Null beginnt.

Verwende innerhalb von [ ] kein bloßes > für einen numerischen Test. In [ 10 > 9 ] leitet Bash die Ausgabe in eine Datei namens 9 um und prüft das verbleibende nicht leere Wort. In [[ 10 < 9 ]] von Bash vergleicht der Operator Zeichenketten, sodass das erste Zeichen 1 vor 9 einsortiert wird. Verwende für numerische Vergleiche -lt oder -gt oder Bash-Arithmetik wie (( count > 100 )).

Bedingungen verknüpfen

[ ! -d "$dir" ] ist erfolgreich, wenn der Pfad kein existierendes Verzeichnis ist; er kann eine reguläre Datei sein oder fehlen. [ -f "$f" ] && [ -r "$f" ] ist nur erfolgreich, wenn beide Tests erfolgreich sind. Separate Tests, die mit || verbunden sind, sind erfolgreich, wenn mindestens einer erfolgreich ist.

Bash hat außerdem das Schlüsselwort für Bedingungen [[ ... ]]. Es verhindert die Wortaufteilung seiner Variablenexpansionen und erlaubt && und || innerhalb des Ausdrucks. Ein Muster ohne Quoting rechts von == führt einen Musterabgleich durch: [[ $file == *.log ]] trifft auf „app.log“ zu. Mit Quoting würde das Muster wörtlich behandelt. Diese Syntax benötigt Bash; dash unterstützt sie nicht.

Bedingungen werden nützlich, wenn sie Aktionen auswählen. Ein if-Block wählt anhand von Befehlsergebnissen einen Zweig. Ein case-Block wählt einen Zweig, indem er einen Wert mit Mustern abgleicht. Beide machen die verfügbaren Aktionen im Skript sichtbar.

Einen Befehl einen Zweig wählen lassen

if grep -q ERROR app.log; then
  echo "Errors found"
else
  echo "No successful match"
fi

if führt den Befehl aus und betritt den ersten Zweig, wenn er 0 liefert. Andernfalls betritt es else. Die Suche selbst ist die Bedingung; du musst sie nicht ausführen, etwas ausgeben und dann $? prüfen. Auch ein grep-Fehler liefert einen Wert ungleich null. Deshalb beschreibt dieses Beispiel den else-Zweig als Suche ohne erfolgreichen Treffer und nicht als Beweis, dass die Datei keine Fehler enthält.

then muss einen neuen Befehl beginnen: Setze es in die nächste Zeile oder nach ein Semikolon. fi schließt den Block. Ein fehlendes fi erzeugt häufig einen Syntaxfehler am Dateiende, weil Bash noch darauf wartet, dass der Block geschlossen wird.

Überlappende Bedingungen ordnen

elif fügt einen Test hinzu, der nur läuft, wenn frühere Tests fehlgeschlagen sind. Für eine ganzzahlige Prozentangabe der Speicherplatzbelegung:

if [ "$usage" -ge 90 ]; then
  echo "CRITICAL: disk ${usage}% full"
elif [ "$usage" -ge 75 ]; then
  echo "WARNING: disk ${usage}% full"
else
  echo "OK: disk ${usage}% full"
fi

Bei usage=82 schlägt der erste Test fehl und der zweite ist erfolgreich. Die Ausgabe lautet „WARNING: disk 82% full“. Bei 95 läuft der erste Zweig und der Warnungszweig wird übersprungen. Stünde der Test auf 75 zuerst, würde 95 darauf zutreffen und der kritische Test nie erreicht werden. Ordne überlappende Bereiche so an, dass die strengere Bedingung zum Zug kommt.

Nur der erste erfolgreiche Zweig wird ausgeführt. else braucht keine Bedingung und behandelt die übrigen Fälle. elif oder else kann entfallen, wenn die Aufgabe den jeweiligen Teil nicht benötigt.

Einen Wert mit case abgleichen

case "$1" in
  start) echo "Starting" ;;
  stop) echo "Stopping" ;;
  y|Y|yes) echo "Confirmed" ;;
  *) echo "Usage: $0 start|stop|y|Y|yes" >&2; exit 2 ;;
esac

Jedes Muster endet mit ), jeder Zweig mit ;; und esac schließt den Block. Das | innerhalb eines Musters gibt Alternativen an. Das abschließende * ist das Auffangmuster und gehört ans Ende, weil es auf jeden Wert zutrifft.

case verwendet Dateimuster, keine regulären Ausdrücke. *.jpg trifft auf einen Wert zu, der mit .jpg endet. [0-9]* trifft auf einen Wert zu, dessen erstes Zeichen eine Ziffer ist; das * kann dann auf beliebigen folgenden Text passen und trifft daher auch auf „7draft“ zu. Es beweist nicht, dass ein ganzer Wert nur Ziffern enthält.

Die passende Struktur wählen

Verwende case, wenn eine Eingabe wie ein Unterbefehl oder eine Antwort mehrere benannte Formen hat. Verwende if, wenn Bedingungen Verschiedenes prüfen, etwa ob eine Datei existiert und ob eine Anzahl eine Schranke überschreitet. Ein Musterabgleich fragt nach den Zeichen in einem Wert; eine Dateiprüfung fragt nach dem Pfad auf dem Datenträger. Ein Name mit der Endung .log kann auf ein Muster passen, selbst wenn keine solche Datei existiert.

Eine for-Schleife gibt demselben Befehlsblock bei jedem Durchlauf einen neuen Wert. Die Liste kann wörtlich angegebene Wörter, passende Dateinamen, einen Zahlenbereich oder die Argumente des Skripts enthalten. Bash weist der Schleifenvariable ein Listenelement zu, bevor der Schleifenkörper ausgeführt wird.

Eine feste Liste durchlaufen

for host in web1 web2 db1; do
  echo "Checking $host"
done

Im ersten Durchlauf gilt host=web1, im zweiten host=web2 und im dritten host=db1. Die Schleife gibt drei Zeilen aus. do öffnet den Schleifenkörper und done schließt ihn. Die Variable bleibt nach der Schleife verfügbar und enthält ihren zuletzt zugewiesenen Wert.

Eine Schleife kann auch ein Ergebnis aufsummieren:

total=0
for n in 4 8 15; do
  total=$(( total + n ))
done
echo "$total"

Die gespeicherte Summe ändert sich von 0 auf 4, dann auf 12 und dann auf 27. Initialisiere die Summe vor der Schleife, damit die erste Addition einen definierten Ausgangswert hat.

Passende Dateien durchlaufen

for f in *.log; do
  [ -f "$f" ] || continue
  gzip -- "$f"
done

Bash expandiert das Glob-Muster zu passenden Namen, bevor der Schleifenkörper läuft. Jeder passende Dateiname bleibt ein Listenelement, auch wenn er Leerzeichen enthält. Das Quoting von "$f" innerhalb des Schleifenkörpers hält dieses Element bei der Übergabe an gzip zusammen. Die Prüfung auf reguläre Dateien überspringt hier auch Verzeichnisse, deren Namen auf .log enden.

Mit den standardmäßigen Glob-Einstellungen von Bash bleibt ein *.log ohne Treffer wörtlich erhalten. Eine Schleife ohne Schutzprüfung würde einmal mit den Zeichen *.log laufen und der Befehl würde fehlschlagen. [ -e "$f" ] || continue überspringt nicht existierende Pfade; verwende -f, wenn nur reguläre Dateien gewünscht sind.

Erstelle keine Dateinamenschleife aus $(ls). Dessen Ausgabe ist Text, sodass die Wortaufteilung „my report.txt“ in zwei Listenelemente zerlegen kann. Ein Glob-Muster liefert die Dateinamen bereits mit ihren vollständigen Grenzen.

Aus jedem alten Namen einen neuen bilden

for f in *.jpeg; do
  [ -f "$f" ] || continue
  mv -- "$f" "${f%.jpeg}.jpg"
done

${f%.jpeg} entfernt die Endung .jpeg aus dem Wert. Für „beach day.jpeg“ wird das Ziel zu „beach day.jpg“. Die beiden Argumente in Anführungszeichen halten beide Pfade zusammen. -- teilt mv mit, dass die folgenden Argumente Namen sind, selbst wenn einer mit - beginnt. Verwende beim Ausprobieren des Beispiels ein Zielverzeichnis ohne gleichnamige Dateien, da mv ein existierendes Ziel ersetzen kann.

Einen Bereich durchzählen

for i in {1..5} liefert 1 bis 5. Bash expandiert die geschweiften Klammern vor den Variablen, sodass {1..$n} keinen Bereich variabler Länge erzeugt. Verwende für eine gespeicherte Schranke die arithmetische Form:

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

Der erste Ausdruck initialisiert den Zähler, der mittlere prüft ihn vor jedem Durchlauf und der letzte aktualisiert ihn. Auch for i in $(seq 1 "$n") erzeugt für eine passende positive ganzzahlige Schranke eine Zahlenliste. Die hier absichtlich ohne Quoting verwendete Substitution liefert separate Zahlen.

Für Argumente liefert for arg in "$@" ein Element pro ursprünglichem Argument. Das kürzere for arg; do bedeutet dasselbe und erhält auch Leerzeichen innerhalb jedes Arguments.

Manche Wiederholungen enden, wenn sich eine Bedingung ändert, und nicht, wenn eine Liste aufgebraucht ist. while und until prüfen vor jedem Durchlauf. Ein while-Schleifenkörper läuft, solange seine Bedingung erfolgreich ist; ein until-Schleifenkörper läuft, solange seine Bedingung fehlschlägt. Beide Schleifen können auch kein einziges Mal laufen.

Aktualisieren, wovon die Bedingung abhängt

i=1
while [ "$i" -le 3 ]; do
  echo "Attempt $i"
  i=$(( i + 1 ))
done

Die Bedingung erhält zuerst 1, dann 2 und dann 3. Der Schleifenkörper gibt diese drei Versuchsnummern aus und erhöht den Zähler jedes Mal. Nach der Aktualisierung auf 4 schlägt der nächste Test fehl und die Schleife endet. Fehlte die Aktualisierung, bliebe i bei 1 und die Schleife liefe weiter. Strg+C stoppt eine laufende Vordergrundschleife.

Um auf eine Datei zu warten:

until [ -f /tmp/export.done ]; do
  sleep 5
done

Existiert die Datei bereits, läuft der Schleifenkörper kein einziges Mal. Andernfalls pausiert sleep 5 fünf Sekunden vor der nächsten Prüfung. Eine Pause verhindert, dass die Schleife ununterbrochen prüft und Prozessorzeit verschwendet.

Datensätze als Zeilen lesen

while IFS= read -r line; do
  echo "Host: $line"
done < hosts.txt

read liefert bei jedem Durchlauf eine Zeile und gibt am Dateiende einen Fehlerstatus zurück. IFS= erhält Leerzeichen am Anfang und Ende der Zeile; -r erhält Backslashes. Die Eingabeumleitung nach done führt die Datei der gesamten Schleife zu, nicht nur ihrem letzten Befehl.

Eine Zeile wie „web1 production“ bleibt ein Wert. for line in $(cat hosts.txt) würde an Leerzeichen, Tabulatoren und Zeilenvorschüben aufteilen und diese beiden Wörter als separate Schleifendurchläufe behandeln. Diese Form kann beliebige zeilenbasierte Datensätze nicht erhalten.

Änderungen nach der Schleife erhalten

Eine Pipe in eine Schleife wie cat hosts.txt | while read -r line; do ...; done führt die Schleife in Bash normalerweise in einem Kindprozess aus. Ein dort geänderter Zähler geht für den Elternprozess verloren, wenn der Kindprozess endet. Leite die Datei in die Schleife um, wenn spätere Befehle deren aufsummierte Werte benötigen:

count=0
while IFS= read -r line; do
  count=$(( count + 1 ))
done < hosts.txt
echo "$count"

Dies verarbeitet Zeilen mit abschließendem Zeilenvorschub und erhält den aktualisierten Zähler in der aktuellen Shell. Für die Schleife erzeugt keine Pipeline einen Kindprozess.

Den letzten Datensatz und vorzeitige Abbrüche behandeln

Eine Datei kann mit Text, aber ohne abschließenden Zeilenvorschub enden. read speichert diesen letzten Text, meldet aber einen Fehlschlag, sodass ein einfaches while read für diesen Datensatz nicht in den Schleifenkörper eintritt. Ergänze einen zweiten Test, um den gespeicherten nicht leeren Text anzunehmen:

while IFS= read -r line || [ -n "$line" ]; do
  echo "Host: $line"
done < hosts.txt

break verlässt die Schleife sofort. continue überspringt die verbleibenden Befehle des aktuellen Durchlaufs und kehrt dann zur nächsten Bedingungsprüfung zurück. Eine while true-Schleife braucht daher ein break, ein exit oder ein Signal, um zu enden. Sie kann ein Menü steuern, das bei der Eingabe „q“ abbricht. Setze in einer Zählschleife eine Aktualisierung vor jedes continue, das sie sonst überspringen würde, da sich dieser Durchlauf andernfalls endlos wiederholen könnte.

Argumente machen aus einem Skript mit festen Eingaben einen wiederverwendbaren Befehl. Bash legt die Wörter nach dem Skriptnamen in Positionsparametern ab. Ihre Grenzen werden von der aufrufenden Shell festgelegt. Daher ist Quoting sowohl beim Aufruf des Skripts als auch bei der Verwendung dieser Werte wichtig.

Die Parameter bestimmen

./backup.sh /home/sam/docs /mnt/usb

Innerhalb des Skripts ist $0 gleich ./backup.sh, $1 gleich /home/sam/docs und $2 gleich /mnt/usb. $# ist 2, die Anzahl der Argumente. Das Skript kann mit cp -r "$1" "$2" das Quellverzeichnis an das Ziel kopieren, ohne einen der beiden Pfade fest im Code vorzugeben.

$0 bezeichnet den Namen, mit dem das Skript gestartet wurde; er wird in $# nicht mitgezählt. Bei ./greet.sh Ana "Lee Kim" ist das erste Argument „Ana“ und das zweite „Lee Kim“. Ohne die Anführungszeichen um den zweiten Namen würde das Skript drei Argumente erhalten.

Ab dem zehnten Argument geschweifte Klammern verwenden

$1 bis $9 bezeichnen die ersten neun Positionsparameter. Der zehnte braucht ${10} und spätere Positionen folgen derselben Form. $10 bedeutet die Expansion von $1, gefolgt vom wörtlichen Zeichen 0. Ist das erste Argument „Ana“, wird $10 zu „Ana0“, selbst wenn ein zehntes Argument existiert.

Ein ausgelassener Parameter wird bei normalen Einstellungen zu leerem Text expandiert. Bei zwei Argumenten fehlt $3; unter set -u verursacht dessen Expansion einen Fehler wegen einer nicht gesetzten Variable. Prüfe die Anzahl, bevor du erforderliche Positionen liest, oder verwende eine Expansion, die einen Standardwert liefert.

Alle Argumentgrenzen erhalten

Angenommen, ein Skript erhält "a b" und c. Vergleiche:

"$@" ist die übliche Wahl für die Argumentweitergabe:

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

Bei diesem Aufruf läuft die Schleife zweimal, einmal pro ursprünglichem Argument. Ohne Argumente läuft sie kein einziges Mal. Das doppelte Quoting von "$@" hat eine besondere Bedeutung: Jeder Positionsparameter bleibt ein separates Wort. Die Anführungszeichen verbinden also nicht die gesamte Liste zu einem Wort.

"$*" verbindet Werte mit dem ersten Zeichen von IFS, gewöhnlich einem Leerzeichen. Das kann für eine einzelne Anzeigezeichenkette nützlich sein, verliert aber die einzelnen Grenzen, die ein späterer Befehl benötigen kann.

Parameter mit shift abarbeiten

shift entfernt den ersten Positionsparameter, verschiebt die späteren nach unten und verringert $#. Beim Sicherungsaufruf wird $1 nach einem Verschieben zu /mnt/usb und die Anzahl zu 1. shift 2 entfernt die ersten beiden Parameter auf einmal.

Damit lässt sich eine Schleife erstellen, die $1 untersucht, verarbeitet und dann vor dem nächsten Durchlauf verschiebt. Prüfe mit [ "$#" -gt 0 ], ob Argumente übrig sind; andernfalls kann das Skript einen fehlenden Wert lesen oder versuchen, über die verfügbaren Argumente hinaus zu verschieben. Das Verschieben ändert $0 nicht und kann die Argumentliste der Eltern-Shell, die das Skript gestartet hat, nicht ändern.

Ein Skript sollte vor Arbeitsbeginn feststellen, ob seine Eingaben brauchbar sind. Prüfe zuerst die Anzahl der Argumente und dann ihre Bedeutung. Optionale Eingaben können Standardwerte haben; fehlende erforderliche Eingaben brauchen eine klare Diagnosemeldung und einen Rückgabestatus ungleich null.

Den erwarteten Aufruf erklären

if [ "$#" -ne 2 ]; then
  echo "Usage: $0 SOURCE DEST" >&2
  exit 2
fi

Dies prüft die Anzahl vor der Expansion von $1 oder $2 und funktioniert daher auch unter set -u. Der Aufrufhinweis geht an die Standardfehlerausgabe. Großbuchstaben bezeichnen Werte, die der Benutzer angibt, [DEST] würde ein optionales Ziel bedeuten und FILE... bedeutet ein oder mehrere Dateiargumente. Eine Hilfeoption wie -h gibt normalerweise den Aufrufhinweis aus und beendet das Skript mit 0, weil das Anfordern von Hilfe eine erfolgreiche Verwendung ist.

Die Argumentanzahl allein kann nicht zeigen, ob eine Quelle brauchbar ist. [ -d "$1" ] prüft auf ein existierendes Verzeichnis. Eine Prüfung auf reguläre Dateien kann Dateien auswählen, aber auch das Ergebnis der Operation selbst muss geprüft werden: Rechte oder andere Fehler können das Lesen verhindern.

Einen Standardwert verwenden oder einen Wert verlangen

logdir=${1:-/var/log}
src=${1:?Usage: backup.sh SOURCE [DEST]}

Die erste Form verwendet /var/log, wenn der erste Parameter fehlt oder leer ist. Die zweite beendet in beiden Fällen ein nicht interaktives Skript und gibt seine Meldung auf der Standardfehlerausgabe aus. Der Doppelpunkt ist Teil beider Formen. Ein Standardwert wird für diese Expansion verwendet; ${1:-...} fügt der Liste der Positionsparameter kein Argument hinzu.

Einen teilweisen Fehlschlag festhalten

Ein Skript zum Zählen von Dateizeilen kann nach einer fehlerhaften Eingabe fortfahren und dennoch melden, dass die gesamte Aufgabe unvollständig war:

#!/bin/bash
if [ "$#" -eq 0 ]; then
  echo "Usage: $0 FILE..." >&2
  exit 2
fi
status=0
for f in "$@"; do
  if [ -f "$f" ]; then
    if lines=$(wc -l < "$f"); then
      echo "$f: $lines lines"
    else
      echo "$f: could not count lines" >&2
      status=1
    fi
  else
    echo "$f: not a regular file" >&2
    status=1
  fi
done
exit "$status"

Für notes.txt missing.txt gibt das Skript die Zeilenanzahl der lesbaren Datei aus und meldet die fehlende Datei. Anschließend endet es mit 1. Die Zuweisung wird direkt geprüft, sodass ein Lesefehler nicht zu einer erfolgreichen leeren Anzahl wird. Ein späterer Erfolg setzt das gespeicherte Fehlerkennzeichen nie auf 0 zurück.

Einfache Optionen vor Dateinamen verarbeiten

verbose=0
while [ "$#" -gt 0 ]; do
  case "$1" in
    -v) verbose=1; shift ;;
    -h) echo "Usage: $0 [-v] FILE..."; exit 0 ;;
    --) shift; break ;;
    -*) echo "Unknown option: $1" >&2; exit 2 ;;
    *) break ;;
  esac
done

Jede erkannte Option wird mit shift abgearbeitet. Das erste gewöhnliche Argument beendet die Optionsauswertung; -- beendet sie ebenfalls und wird selbst entfernt. Das verbleibende "$@" enthält die Dateinamen, einschließlich eines Namens, der nach -- mit - beginnt. getopts von Bash unterstützt eine umfassendere Auswertung kurzer Optionen.

Ein unbeaufsichtigtes Skript benötigt alle erforderlichen Eingaben aus Argumenten, Standardwerten oder der Konfiguration. read kann auf ein Terminal warten und blockieren oder am Dateiende sofort fehlschlagen. Würde ein fehlendes Argument durch eine Eingabeaufforderung ersetzt, hätte eine geplante Aufgabe keine zuverlässige Möglichkeit fortzufahren.

Cron startet Befehle zu passenden Uhrzeiten. Die Crontab jedes Benutzers speichert dessen Zeitplan und Aufgaben laufen unter dessen Benutzerkonto. Ein geplantes Skript braucht sowohl einen korrekten Zeitausdruck als auch eine Umgebung, die seine Pfade, Eingaben und sein Ausgabeziel bereitstellt.

Die fünf Felder lesen

Verwende crontab -e, um deine Tabelle zu bearbeiten, und crontab -l, um sie anzusehen. crontab -r löscht die gesamte Tabelle ohne Nachfrage; verwende den Editor, um eine einzelne Aufgabe zu entfernen.

30 2 * * * /home/sam/bin/backup.sh

Dies läuft täglich um 02:30 Uhr. Sternchen akzeptieren jeden Wert in einem Feld. 0 9 * * 1-5 wählt montags bis freitags 09:00 Uhr und 0 0 1 * * Mitternacht am ersten Tag jedes Monats. Zeiten verwenden die Zeitzone des Systems, sofern die cron-Konfiguration keine andere unterstützte Zeitzone festlegt.

Bereiche, Listen und Schrittweiten kombinieren

Ein Komma listet Werte auf: 1,15 im Feld für den Monatstag wählt den ersten und den fünfzehnten Tag. Ein Bindestrich gibt einen Bereich an und / leitet eine Schrittweite ein. */15 im Minutenfeld wählt 0, 15, 30 und 45.

*/20 8-10 * * * wählt drei Minuten in jeder von drei Stunden: neun tägliche Läufe, beginnend um 08:00 Uhr und endend um 10:40 Uhr. Schrittweiten beginnen innerhalb ihres Feldes neu. */45 läuft zu Minute 0 und Minute 45 jeder Stunde; der Abstand bis zur Minute 0 der folgenden Stunde beträgt nur 15 Minuten.

Sind sowohl der Monatstag als auch der Wochentag eingeschränkt, reicht eine Übereinstimmung in einem der beiden Felder. 0 12 13 * 5 wählt mittags am 13. und an Freitagen, nicht nur an einem Freitag, dem 13. Die anderen Felder müssen weiterhin zutreffen.

Spezielle Zeichenfolgen ersetzen alle fünf Felder: @hourly, @daily, @weekly, @monthly, @yearly und @reboot. @daily bedeutet Mitternacht, während @reboot einmal beim Start läuft.

Pfade bereitstellen und die Ausgabe erhalten

Cron verwendet normalerweise /bin/sh für seine Befehlszeile, einen kurzen PATH und keine Startdatei-Einstellungen einer interaktiven Shell. Der Bash-Shebang eines ausführbaren Skripts wählt weiterhin Bash. Verwende absolute Pfade für das Skript und seine Dateien oder setze PATH am Anfang der Crontab.

30 2 * * * /home/sam/bin/backup.sh >> /home/sam/backup.log 2>&1

Die Aufgabe hängt beide Ausgabeströme an das Protokoll an. Ohne Umleitung versendet cron die Ausgabe per E-Mail, wenn der Mailversand konfiguriert ist, auch über MAILTO; andernfalls kann die Ausgabe verloren gehen. Ein Prozentzeichen hat in einem Crontab-Befehl eine besondere Funktion: Es beginnt eine neue Zeile und die nachfolgende Eingabe. Maskiere dort ein Datumsformat wie in date +\%F. Ein Datumsbefehl innerhalb eines separaten Skripts verwendet das gewöhnliche %F.

Systemzeitpläne und nachgeholte Aufgaben unterscheiden

/etc/crontab und Dateien in /etc/cron.d/ ergänzen nach den fünf Zeitfeldern ein Benutzerfeld. Zum Beispiel läuft 30 2 * * * root /usr/local/bin/backup.sh als root. Füge dieses Benutzerfeld nicht zu einer persönlichen Crontab hinzu.

Viele Distributionen führen auch geeignete ausführbare Dateien in /etc/cron.daily/, /etc/cron.weekly/ und /etc/cron.monthly/ aus. Die Standardregeln für Namen von Debians run-parts überspringen Namen mit Punkten. Verwende dort daher backup-notes und nicht backup-notes.sh. Cron verpasst Zeiten, die bei ausgeschaltetem Computer verstreichen. Anacron kann regelmäßige tägliche, wöchentliche oder monatliche Aufgaben nach dem Start nachholen.

Systemd trennt die Arbeit von ihrem Zeitplan. Eine Service-Unit beschreibt den auszuführenden Befehl. Eine Timer-Unit beschreibt, wann er gestartet wird. Standardmäßig aktiviert backup.timer die Unit backup.service und verbindet das Paar über den gemeinsamen Grundnamen.

Den Dienst und den kalenderbasierten Zeitplan schreiben

Lege diese System-Units in /etc/systemd/system/ ab:

# backup.service
[Unit]
Description=Nightly backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

Type=oneshot eignet sich für ein Skript, das einmal läuft und endet. Verwende einen absoluten Befehlspfad und mache das Skript mit einem Bash-Shebang ausführbar. Der Timer liefert den Zeitplan:

# backup.timer
[Unit]
Description=Run backup.service daily at 02:30

[Timer]
OnCalendar=*-*-* 02:30:00
Persistent=true

[Install]
WantedBy=timers.target

OnCalendar gleicht Datumsangaben und Uhrzeiten ab. Hier akzeptiert das Datum mit Platzhaltern jeden Tag. Persistent=true ermöglicht das Nachholen, nachdem der Timer inaktiv war: Wurde mindestens ein kalenderbasierter Lauf verpasst, startet der Timer den Dienst bei erneuter Aktivierung einmal. Er führt nicht jeden verpassten Lauf erneut aus.

Den Timer laden und aktivieren

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer

Lade nach dem Anlegen oder Ändern von Unit-Dateien neu. enable --now startet den Timer sofort und aktiviert ihn für künftige Systemstarts. Die alleinige Aktivierung des Dienstes erstellt keinen Zeitplan. Teste die Arbeit separat mit sudo systemctl start backup.service.

Zwischen Uhrzeit und verstrichener Zeit wählen

Kalenderausdrücke können daily für Mitternacht an jedem Tag oder weekly für Montag um Mitternacht verwenden. Prüfe einen Ausdruck mit systemd-analyze calendar "Mon..Fri 09:00", um seine Interpretation und den nächsten Termin zu sehen.

Die letzten beiden Einstellungen sind monotone Timer: Sie messen die seit einem Ereignis verstrichene Zeit. Kombiniere sie für einen ersten Lauf nach dem Systemstart und spätere stündliche Aktivierungen. Persistent=true gilt für kalenderbasierte Timer; es ergänzt kein kalenderbasiertes Nachholen für monotone Timer.

Zeitplanung und Ergebnisse getrennt untersuchen

systemctl list-timers zeigt die nächsten und letzten Aktivierungen. systemctl status backup.service zeigt das Ergebnis des Dienstes und journalctl -u backup.service dessen Ausgabe und Fehler. Ein aufgelisteter nächster Lauf zeigt, dass ein Zeitplan aktiv ist, aber nicht, dass die vorherige Aufgabe des Skripts erfolgreich war.

Timer haben ein Auslösefenster. AccuracySec beträgt standardmäßig eine Minute; AccuracySec=1s verkleinert das Zeitfenster für die Zusammenfassung von Auslösungen. RandomizedDelaySec fügt absichtlich eine zufällige Verzögerung hinzu, um Arbeit auf mehrere Rechner zu verteilen. Diese Einstellungen garantieren unter Last keine exakte Startsekunde.

Einen eigenen Benutzer-Timer ausführen

Benutzer-Unit-Dateien liegen in ~/.config/systemd/user/ und Befehle verwenden systemctl --user, auch daemon-reload, enable --now und list-timers. Ein Benutzermanager läuft normalerweise mit der Sitzung dieses Benutzers. Ein Administrator kann Lingering mit loginctl enable-linger username aktivieren, um ihn auch ohne Anmeldung verfügbar zu halten.

Cron benötigt eine kompakte Zeitzeile und funktioniert ohne systemd. Timer ergänzen ein Dienstergebnis und ein Journal, das Nachholen kalenderbasierter Aufgaben und mehr Kontrolle. Normalerweise lädt keines von beiden ~/.bashrc; beide benötigen Skripte, die mit ausdrücklichen Pfaden und ohne interaktive Eingabeaufforderungen funktionieren.