Für das Verständnis der Kommandozeile ist es wichtig zu wissen, wie die Bash die Zeichen bewertet. Dabei wird unterschieden zwischen Zeichen(kombinationen) mit spezieller Bedeutung und normalen Zeichen:

• Zeichen, die immer einzeln wirken
  • Quoting-Zeichen: \, ", '
  • Metacharacter (reine Worttrenner): space, tab, newline
  • Metacharacter (Worttrenner mit weiterer Bedeutung): |, &, ;, (, ), <, >
  • veraltete Form der Kommando-Substitution (jetzt: $( )): `
  • Pattern-Matching: *, ?
• Zeichen, die als komplettes Wort eine Sonderbedeutung haben
  • Reservierte Wörter (einzelne Zeichen): !, {, }
• Zeichen, die nur am Wortanfang eine Sonderbedeutung haben
  • Kommentarzeichen: #
  • Tilde-Expansion (Homeverzeichnis): ~
• Zeichen, die später in einem Wort eine Sonderbedeutung haben
  • Variablenzuweisung: =
• Zeichen, die am Anfang bestimmter Zeichenfolgen eine Sonderbedeutung haben
  • Brace-Expansion: {
  • Variablen, Kommandosubstitution, Arithmetik-Expansion, ANSI-C-Quoting: $
  • einfaches Pattern-Matching: [
  • Pattern-Matching (extglob): @, +, *, ?, !
• Zeichen, die später in einer bestimmten Zeichenfolge eine Sonderbedeutung haben
  • Brace-Expansion: }
  • einfaches Pattern-Matching: ]
• Reservierte Wörter (Zeichenfolgen): case coproc do done elif else esac fi for function if in select then until while time [[ ]]
• vorbelegte Wörter (abschaltbar)
  • eingebaute Befehle (builtins)
  • Aliase

Die einfachste Kommandozeile besteht aus nur einem Wort und endet mit newline, ;, & oder dem Ende der Eingabe (Script oder bash -c / bash -s). Eine Bash-Eingabezeile kann mehrere Kommandos / Kommandozeilen enthalten.

printf '%s  '   \\   \'   \"   '"'   "'"   '\'   "\\"   $'\"\'\\'
\  '  "  "  '  \  \  "'\

Eine interaktive Shell erwartet Benutzereingaben auf der Standardeingabe (abgesehen von exotischen Spezialfällen mit -i). Das ist normalerweise ein Terminal. Wenn die Bash erkennt, dass die Standardeingabe und die Standardfehlerausgabe ein Terminal sind und dass sie weder ein Dateiargument noch die -c-Argumentoption hat, betrachtet sie sich als interaktiv und produziert einen Prompt. Normalerweise weiß man, ob man sich in einer interaktiven Shell befindet, aber wenn man eine Shellfunktion ausführt, die in beiden Varianten verwendet werden kann, kann man dies mit [[ $- == *i* ]] testen.

Man kann Shellcode in eine Datei – das Script – schreiben und dann entweder die Bash mit dieser Datei als Argument aufrufen oder diese Datei direkt als Kommando, wenn sie ausführbar ist und mit einer Shebang-Zeile (üblicherweise #! /bin/bash oder #! /usr/bin/bash) beginnt. Eine überschaubare Menge an Shellcode, der in einer unabhängigen, frisch initialisierten Shell laufen soll, kann man mit bash -c 'echo foo; echo bar' ausführen. Anstatt ein Script erst auf ein anderes System zu kopieren und dort über Umgebungsvariablen (ssh targethost env var=foo /path/to/script.sh) oder Argumente zu konfigurieren, kann man auch eine Shell starten, die ihre Eingaben via SSH aus einem Script (v. a. mit einem Here-Document, in dem man die Variablen bequem setzen kann) bekommt:

{
    cat <<-EOT # weil EOT nicht gequotet ist, wird ${var} ersetzt
    var='${var}'
    EOT
    cat <<-'EOT'
    # hier kann ein langes Script stehen
    # der Code wird wegen des 'EOT'-Quotings literal übermittelt
    ...
    EOT
} | ssh host bash -s

In einer nichtinteraktiven Shell gibt es keinen Prompt und wird Readline nicht verwendet. Außerdem sind einige Funktionen deaktiviert (aber aktivierbar): Aliase, history expansion und job control. Es werden keine Startdateien abgearbeitet, es sei denn in der Umgebungsvariable BASH_ENV ist ein solcher Pfad definiert oder die Bash erkennt, dass ihre Standardeingabe an einer SSH-Verbindung hängt.

Die Bash verhält sich anders, wenn sie als Login-Shell gestartet wird. Der Name bezieht sich darauf, dass Login-Shells zumeist von Daemonen (SSH) und ähnlichen Programmen (login auf den virtuellen Konsolen, su und sudo in einer Shell) erzeugt werden. Dies sind Programme, die mit root-Rechten laufen und deshalb die Möglichkeit haben

• eine Authentifizierung durchzuführen
  • über eigene Methoden (SSH mit Schlüsseln)
  • oder über die Methoden des Systems (v. a. Passwortprüfung, unter Linux via PAM)
• eine Shell als ein beliebiger Benutzer zu starten (eine root-Shell ist nicht automatisch eine Login-Shell)

Eine Login-Shell ist dafür gedacht, der erste vom Benutzer konfigurierbare Prozess in einer Prozesshierarchie zu sein. Nur der erste Prozess muss bestimmte Einstellungen vornehmen, da diese an seine Kindprozesse vererbt werden. Deshalb ist die Initialisierung einer Login-Shell umfangreicher als die einer normalen Shell. Die bash-spezifische Initialisierung ist normalerweise für beide Arten identisch. Die Bash erkennt auf zwei Arten, dass sie als Login-Shell laufen soll:

• Der Kommandoname in $0, der von dem aufrufenden Programm gesetzt wird, beginnt mit - (-bash, -sh, -rbash).
• Sie wird mit der Argumentoption -l / --login aufgerufen.

Man kann mit shopt login_shell herausfinden, ob eine Shell eine Login-Shell ist.

Die Bash wird durch eine Reihe von Konfigurationsdateien konfiguriert. Hierbei ist zu unterscheiden zwischen systemweiter und benutzerspezifischer Konfiguration.

Bash hat zwei Kategorien von Konfigurationsmöglichkeiten, die von unterschiedlichen eingebauten Befehlen (builtins) verwaltet werden: set und shopt. Beide können auch beim Aufruf der Shell über Argumentoptionen konfiguriert werden.

$ bash -c 'echo -n /e?c; echo "   $-"'
/etc   hBc
$ bash -c 'set -f ; echo -n /e?c; echo "   $-"'
/e?c   fhBc
$ bash -f -c 'echo -n /e?c; echo "   $-"'
/e?c   fhBc

# aktuellen Stand sichern
$ set_restore="$( set +o )"
set +o | grep -q 'set -o errexit' && set_restore+=$'\nset -o errexit\n'
# Konfiguration ändern
$ set -o allexport
# gesicherten Stand wiederherstellen
$ eval "$set_restore" 2>/dev/null # ggf. irrelevante Fehlermeldungen ignorieren

# aktuellen Stand sichern
$ shopt_restore="$( shopt -p )"
# Konfiguration ändern
$ shopt -s nullglob
# gesicherten Stand wiederherstellen
$ eval "$shopt_restore"

Als Wildcards verwendet die Bash

• * für beliebig viele Zeichen (also auch keines)
• ** nur pathname expansion: alle Dateien, Verzeichnisse und deren Unterverzeichnisse
• **/ nur pathname expansion: alle Verzeichnisse und deren Unterverzeichnisse
• ? für genau ein beliebiges Zeichen
• [...] für genau eins der zwischen den eckigen Klammern aufgelisteten Zeichen
• [^...] / [!...] für genau ein Zeichen, das nicht zwischen den eckigen Klammern aufgelistet ist
• [a-eF-J0-4] für genau eins der Zeichen aus einem Zeichenbereich, der durch das Locale (Sortierreihenfolge) oder die Shelloption globasciiranges (auf C) festgelegt wird
• [[:class:]] für genau eins der Zeichen aus einer Zeichenklasse
• [[=,=]] für genau eins der Zeichen aus der Äquivalenzklasse (z. B. ,, ;, .) des angegebenen Zeichens

Die verfügbaren Zeichenklassen sind dieselben wie bei regulären Ausdrücken: [:alnum:], [:alpha:], [:ascii:], [:blank:], [:cntrl:], [:digit:], [:graph:], [:lower:], [:print:], [:punct:], [:space:], [:upper:], [:word:], [:xdigit:]

Mit shopt -s extglob kann man extended globbing aktivieren. Diese Funktion stellt fünf Klammerausdrücke zur Verfügung, die einen oder mehrere alternative Muster enthalten, die wiederum Wildcards und Klammerausdrücke enthalten können: @(foo|bar) passt auf entweder foo oder bar.

Wenn sich ein Klammermuster wiederholen darf (*(foo), +(foo)), dann bezieht sich die Wiederholung auf das Muster, nicht auf das Zeichen, das beim ersten Mal getroffen wurde! Der Klammerausdruck kann also eine Zeichenkette aus unterschiedlichen Zeichen treffen.

Die Bash unterstützt erweiterte reguläre Ausdrücke. Diese stehen nur in dieser Form zur Verfügung:

[[ $zeichenkette =~ $pattern ]], z. B. [[ $zeichenkette =~ ^.*\.txt~?$ ]]

Beide Varianten können sowohl in abstraktem pattern matching mit beliebigen Zeichenketten als auch mit pathname expansion verwendet werden.

Beliebige Zeichenketten können mit dem [[ ]]-Kommando getestet werden:

• [[ foo == f[o]? ]] / [[ foo != f[o]? ]]
• [[ $dateiname == *.conf ]] / [[ $dateiname != *.conf ]]
• [[ $systemd_unit_name == *.@(service|target|mount|timer) ]]

Pathname expansion ist die allgemein bekannte Verwendung von Wildcards zum Erfassen aller oder nur bestimmter real existierender Dateinamen / Dateipfade. Vor Bash 4.0 war pathname expansion nur in einer bestimmten Verzeichnisebene möglich (keine Rekursion). Inzwischen kann man mit shopt -s globstar das rekursive Erfassen aller Unterverzeichnisse mittels ** aktivieren.

Für die folgenden Beispiele werden mit den Kommandos

mkdir -p subdir/subsubdir ; touch datei datei{1..3} datei{,1,2}.{txt,conf} archiv.tar subdir/{,subsubdir/}archiv.tar

diese Dateien und Unterverzeichnisse angelegt:

datei datei1 datei2 datei3 datei.txt datei.conf datei1.txt datei1.conf datei2.txt datei2.conf archiv.tar subdir/archiv.tar subdir/subsubdir/archiv.tar

Die Shelloption nullglob (shopt -s nullglob) steuert die Reaktion der Bash, wenn ein Muster bei pathname expansion keine Treffer generiert. Standardmäßig ist diese Option abgeschaltet, dann bleibt das Muster unverändert stehen, was selten sinnvoll ist, wenn pathname expansion beabsichtigt war. Es funktioniert, wenn eine Zeichenkette mit Wildcards als Argument übergeben werden soll, etwa in

find . -type f -name *.conf

Aber solche Aufrufe sollte man grundsätzlich vermeiden und immer mit Quoting arbeiten (-name '*.conf'). Wenn die Shelloption nullglob angeschaltet ist, wird das Muster komplett aus der Kommandozeile entfernt. Auch das kann unerwünscht sein. Es gibt zwei Möglichkeiten, den Fall fehlender Treffer zu handhaben:

• explizit: if ( shopt -s nullglob ; set -- *pattern* ; (( $# )) ) ; then ...
• Man setzt die Shelloption failglob (shopt -s failglob), dann führt die Shell die Kommandozeile gar nicht erst aus, wenn eins der Muster in der Kommandozeile keine Treffer generiert:

  $ echo *nomatch*
  bash: Keine Entsprechung: *nomatch*
  
  # oder
  if ( shopt -s failglob; : *nomatch* ) 2>/dev/null ; then ...
  

Man kann nullglob auch ohne „echtes“ pattern matching nutzen, um Einträge aus einer Argumentliste zu entfernen, wenn die entsprechende Datei nicht existiert:

$ touch datei_existiert
$ echo datei_existier[t] datei_existiert_nich[t]
datei_existiert
$ touch datei_existiert_nicht
$ echo datei_existier[t] datei_existiert_nich[t]
datei_existiert datei_existiert_nicht

Mit der Shelloption nocaseglob (shopt -s nocaseglob) kann man dafür sorgen, dass die Groß-Klein-Schreibung bei der Trefferprüfung ignoriert wird.

Mit der Shell-Variable GLOBIGNORE kann man Treffer herausfiltern. Ist diese Variable nicht leer, wird die Shelloption dotglob automatisch gesetzt und werden die Treffer . und .. immer ignoriert.

Pathname expansion erfasst standardmäßig keine versteckten Dateinamen; das sind diejenigen, die mit einem Punkt . beginnen. Es gibt zwei Möglichkeiten, diese Dateien zu erreichen:

• Man adressiert sie direkt, indem man das Suchmuster (innerhalb des Verzeichnisses) mit einem Punkt beginnen lässt. Das hat den Nachteil, dass man nur diejenigen Einträge erfasst, die mit einem Punkt beginnen.
• Mit der Shelloption dotglob (shopt -s dotglob) erfasst * auch versteckte Dateien – mit Ausnahme von . und .., die man also ggf. hinzufügen muss (typischerweise will man die gar nicht in den Ergebnissen haben): ls -ld . .. *

Die Shelloption globskipdots (shopt -s globskipdots) sorgt dafür, dass bei Verwendung des Musters .* die Verzeichnisse . und .. nicht getroffen werden.

Die häufigste Form der expliziten I/O-Konfiguration ist die Umleitung der Standard-Deskriptoren (innerhalb einer Pipeline kümmert sich die Bash automatisch um die nötigen Anpassungen). Die Umleitungsanweisungen können an beliebiger Stelle in der Kommandozeile stehen. Die Bash wertet sie aus und „entfernt“ sie, bevor das Kommando gestartet wird. Das Kommando sieht die Umleitungen nicht als eigenes Argument. Zwischen dem Umleitungszeichen und einem folgenden Dateinamen kann ein Leerzeichen stehen, muss aber nicht. Bei der Umleitung auf einen bestehenden Deskriptor (>&2) darf kein Leerzeichen folgen.

• Wegwerfen der Standardfehlerausgabe. Oftmals will man die Fehlermeldungen nicht sehen:

  $ find /etc/selinux -name '*.LOCK'
  /etc/selinux/targeted/semanage.read.LOCK
  /etc/selinux/targeted/semanage.trans.LOCK
  find: ‘/etc/selinux/targeted/active’: Keine Berechtigung
  find: ‘/etc/selinux/final’: Keine Berechtigung
  
  $ find /etc/selinux -name '*.LOCK' 2>/dev/null
  /etc/selinux/targeted/semanage.read.LOCK
  /etc/selinux/targeted/semanage.trans.LOCK
  

• Umleiten der Standardausgabe in eine Datei

  $ find /etc -type f 2>/dev/null >~/find-etc.txt
  

• Umleiten der Standardeingabe auf eine Datei (d. h. Lesen aus der Datei statt vom Terminal)

  $ while IFS= read -r line; do printf '%s: %s\n' "$inputfile" "$line" ; done < "$inputfile"
  

• Umleiten eines Deskriptors auf den anderen, z. B. die stdout-Ausgabe eines Kommandos auf stderr lenken:

  $ echo foo 1>&2 # oder: echo foo >&2
  

Bei der Eingabeumleitung ist der Standard-Deskriptor 0, bei der Ausgabeumleitung 1. Deshalb kann man statt 0< einfach < verwenden und statt 1> einfach >.

Man kann beide Ausgaben gleichzeitig umleiten:

• beide wegwerfen:
  • beide explizit (Reihenfolge ist egal):
    • $ bash -c 'echo foo >&1 ; echo bar >&2' >/dev/null 2>/dev/null
  • beide Deskriptoren gleichzeitig umleiten:
    • $ bash -c 'echo foo >&1 ; echo bar >&2' &>/dev/null
  • einen Deskriptor explizit umleiten, den anderen auf den ersten kopieren; hier ist die Reihenfolge entscheidend!
    • funktioniert: $ bash -c 'echo foo >&1 ; echo bar >&2' >/dev/null 2>&1
    • funktioniert nicht: $ bash -c 'echo foo >&1 ; echo bar >&2' 2>&1 >/dev/null
• getrennt umleiten (Reihenfolge ist egal):
  • $ find /etc -type f 2>/dev/null >~/find-etc.txt

Die meisten Programme, die eine Eingabe bearbeiten können (grep, awk, sed, cut, cat, nl, fold, …) können direkt mit einer Datei aufgerufen werden, es gibt also selten Grund für grep < file statt grep file. Allerdings schafft die Umleitung ein hohes Maß an Gewissheit, dass das Programm die Datei nicht verändert.

Mit >> statt > kann die Ausgabe an eine bestehende Datei angehängt werden, anstatt die Datei zu überschreiben.

Bei einer Ausgabeumleitung wird die Datei angelegt, wenn sie noch nicht existiert. Eine bestehende Datei wird (ohne Warnung) überschrieben. Wenn man eine Datei nicht löschen, sondern nur ihre Größe auf Null setzen möchte, kann man das also hiermit tun:

$ echo foo >datei
$ ls -l datei
-rw-r----- 1 hl hl 4 19. Aug 02:07 datei # Größe 4 Byte für foo und den Zeilenumbruch am Ende
$ >datei
$ ls -l datei
-rw-r----- 1 hl hl 0 19. Aug 02:09 datei

Wenn man nicht riskieren möchte, dass man eine bestehende Datei versehentlich überschreibt, kann man dies mit der Shelloption noclobber (set -o noclobber) unterbinden.

$ >datei
bash: datei: Kann existierende Datei nicht überschreiben

Man kann dann entweder vor der Umleitung die Datei löschen oder statt > den Umleitungsoperator >| verwenden.

Anstatt pro Kommando einen der Standard-Deskriptoren umzuleiten, kann man dauerhaft weitere anlegen (bis 9 problemlos, bei größeren Werten sollte man prüfen (unter Linux mit test -e /proc/self/fd/42), ob der Deskriptor frei ist, oder die bash mit {varname}>datei einen freien (oberhalb von 9) auswählen lassen). Neue Deskriptoren legt man mit dem eingebauten Shellkommando (builtin) exec an.

• 4 zum Lesen öffnen
  • exec 4<datei_read
  • read line <&4
• 5 zum Schreiben öffnen
  • exec 5>datei_write
  • echo foo >&5
  • echo bar >&5 # überschreibt die Datei trotz > nicht, weil der Deskriptor nicht neu geöffnet wird
• 6 zum Anhängen öffnen
  • exec 6>>datei_append
  • echo foo >&6 # kein >> erforderlich, weil der Deskriptor schon für Anhängen geöffnet ist
  • echo bar >&6
• 7 zum Lesen und Schreiben öffnen
  • exec 7<>datei_read_write
  • read line <&7
  • echo bar >&7
• beliebigen freien Deskriptor (größer 9) zum Lesen öffnen
  • exec {fdname}<datei_read
  • read line <&${fdname}

Einen Deskriptor gleichzeitig zum Lesen und Schreiben zu öffnen ist nicht immer sinnvoll, weil jeder Deskriptor nur eine gemeinsame Position für Lesen und Schreiben hat und deshalb beide Zugriffsarten einander in die Quere kommen können. In diesen Fällen öffnet man unterschiedliche Deskriptoren explizit (keine 5>&4-Deskriptor-Duplikation) auf dieselbe Datei, einen zum Lesen, den anderen zum Schreiben. Schließen kann man einen Deskriptor mit exec 10>&-. Die Variante echo foo {fdname}>datei_write erzeugt auch ohne exec einen dauerhaften Deskriptor (sofern die Shelloption varredir_close nicht gesetzt ist: shopt -s varredir_close).

Unter Linux kann man sich das Ergebnis der unterschiedlichen Varianten so ansehen:

$ ls -l /proc/self/fd
insgesamt 0
lrwx------ 1 hl hl 64 19. Aug 03:04 0 -> /dev/pts/92
lrwx------ 1 hl hl 64 19. Aug 03:04 1 -> /dev/pts/92
lrwx------ 1 hl hl 64 19. Aug 03:04 2 -> /dev/pts/92
lr-x------ 1 hl hl 64 19. Aug 03:04 3 -> /proc/1375879/fd
lr-x------ 1 hl hl 64 19. Aug 03:04 4 -> /.../datei_read
l-wx------ 1 hl hl 64 19. Aug 03:04 5 -> /.../datei_write
l-wx------ 1 hl hl 64 19. Aug 03:04 6 -> /.../datei_append
lrwx------ 1 hl hl 64 19. Aug 03:04 7 -> /.../datei_read_write

$ head /proc/self/fdinfo/5 /proc/self/fdinfo/6
== > /proc/self/fdinfo/5 < ==
pos:    0
flags:  0100001
mnt_id: 114
ino:    19764409

== > /proc/self/fdinfo/6 < ==
pos:    0
flags:  0102001
mnt_id: 114
ino:    19764578

Der Unterschied zwischen > und >> zeigt sich nicht in den /proc-Zugriffsrechten, sondern erst in den unterschiedlichen (oktalen, nicht zwingend auf allen Linux-Systemen identischen) Flags in /proc/self/fdinfo:

Ein Here-Document ist eine Komfort-Funktion zur besseren Handhabung längerer, insbesondere mehrzeiliger Texte. Die Bash behandelt alle Zeilen zwischen der Zeile mit dem Startoperator und der Start-Zeichenkette und der Zeile mit der Ende-Zeichenkette als Inhalt, der auf die Standardeingabe des jeweiligen Kommandos geschrieben wird, so wie cat datei | cmd dies täte, wenn der Text in einer gesonderten Datei stünde. Allerdings gibt es zwei Kategorien für unterschiedliche Betriebsarten:

• Quoting:
  • Wenn das nach dem Startoperator << festgelegte Wort gequotet ist, dann ist die Ende-Zeichenkette (häufig EOT für end of text) das Wort ohne die Quotezeichen und wird der Inhalt literal ausgegeben.
  • Bei einer nicht gequoteten Start-Zeichenkette Werden Parameter-Expansion (${HOME}), Command-Substitution ($( date )) und Arithmetic-Expansion ($((2+3))) auf den Inhalt angewendet, und ein Backslash am Zeilenende und der folgende Zeilenumbruch werden entfernt, was die Ende-Zeichenkette in der nächsten Zeile aufhebt. \, $ und ` können mit \ gequotet werden, um sicherzugehen, dass sie literal verwendet werden:

    $ cat <<EOT
    foo ${HOME} bar $( date +%F ) bat $(( 2+5 )) \$ \` \\ _\
    bar
    bat\
    EOT
    EOT
    
    # Ausgabe ist:
    foo /home/hl bar 2026-08-20 bat 7 $ ` \ _bar
    batEOT
    
    $ cat <<'E O T'
    foo ${HOME} bar $( date +%F ) bat $(( 2+5 )) \$ \` \\ _\
    bar
    bat\
    E O T
    E O T
    
    # Ausgabe ist:
    foo ${HOME} bar $( date +%F ) bat $(( 2+5 )) \$ \` \\ _\
    bar
    bat\
    test.sh: Zeile 16: E: Kommando nicht gefunden
    

• Tabulator-Einrückung: Damit die Inhaltszeilen und die Ende-Zeichenkette die Einrückungsformatierung des Scripts nicht stören, hat man die Möglichkeit, statt << den Operator <<- zu verwenden, wodurch dann Tabulatoren am Zeilenanfang ignoriert werden; sowohl bei den Inhaltszeilen als auch bei der Ende-Zeichenkette:

  function testf () {
          if [ "${condition1}" = '1' ]; then
                  if [ "${condition2}" = '1' ]; then
                          cat <<EOT
  foo ${HOME} bar $( date +%F ) bat $(( 2+5 ))
  EOT
                  fi
          fi
  }
  
  
  function testf () {
          if [ "${condition1}" = '1' ]; then
                  if [ "${condition2}" = '1' ]; then
                          cat <<-EOT
                          foo ${HOME} bar $( date +%F ) bat $(( 2+5 ))
                          EOT
                  fi
          fi
  }
  

Here-Strings sind eine kleinere Variante eines Here-Documents. Man kann ein Kommandozeilen-Wort zur Standardeingabe eines Kommandos machen. Zusätzlich zu den Expansions bei Here-Documents steht hier zusätzlich Tilde-Expansion zur Verfügung:

# cat ist unkritisch, zeigt hier nur die Expansionen
$ cat <<<~hl/"   foo ${HOME} bar $( date +%F ) bat $(( 2+5 ))"
/home/hl/   foo /home/hl bar 2026-08-20 bat 7

$ read hash rest <<<"$( echo foo | sha1sum )"
declare -p hash
declare -- hash="f1d2d2f924e986ac86fdf7b36c94bcdf32beec15"

Dies ist eine überlegene Alternative zu

$ printf '%s\n' ~hl/"   foo ${HOME} bar $( date +%F ) bat $(( 2+5 ))" | cat

# read in einer Pipeline ist kritisch; funktioniert nur mit lastpipe und inaktiver Job-Steuerung
$ echo foo | sha1sum | read hash rest
declare -p hash
bash: declare: hash: Nicht gefunden.

wenn man das Kommando in der normalen Shellumgebung (statt in einer Subshell) ausführen muss, etwa weil man Variablen setzt. Der Vorteil des Here-Strings ist, dass er unabhängig von der Shelloption lastpipe funktioniert.

Man kann auch auf /dev/tcp/host/port und /dev/udp/host/port umleiten (dies sind keine real existierenden Pfade, sondern spezielle Konstrukte, die Bash erkennt):

exec 4<>/dev/tcp/localhost/80
printf 'GET / HTTP/1.0\r\n\r\n' >&4 ; cat <&4

Mit der Pipe (|) lassen sich Kommandos verketten, indem die Ausgabe des ersten mit der Eingabe des zweiten Kommandos verbunden wird, was sich (fast) beliebig verlängern lässt:

user@blablubb:~/test$ ls -l /etc | grep '^d' | wc -l

Der Mechanismus der Umlenkung der Standardkanäle und die Pipe sind keine Besonderheit der Bash.

Diverse Kontrollstrukturen arbeiten mit dem Exit-Status eines Kommandos. Dies ist eine ganze Zahl von 0 bis 255. Normalerweise ist der Bash-Exit-Status der Exit-Code eines externen Kommandos, den der Linux-Kernel an die Bash zurückliefert (bzw. das Äquivalent eines eingebauten Kommandos). Wird das Kommando durch ein Signal beendet, ist der Exit-Status 128 plus die Nummer des Signals (siehe kill -l). Auf den Exit-Status des letzten Kommandos kann man mit $? zugreifen:

$ true ; echo $?
0

$ false ; echo $?
1

Der Exit-Status 0 gilt als wahr, alle anderen als falsch.

Für Test, die innerhalb der Bash stattfinden, also nicht durch ein externes Kommando, sondern etwa

• existiert eine Variable (-v)
• ist die Variable (nicht) leer (-n / -z)
• hat die Variable (nicht) einen bestimmten Inhalt (!=, =)
• entspricht der Inhalt einer Variable einem Pattern-Matching-Ausdruck (Globbing oder Regex, nur [[, siehe dort)
• ist der Inhalt einer Variable eine Zahl, die gleich, größer oder kleiner als eine andere Zahl ist
• existiert ein Pfad im Dateisystem (-a / -e)
• ist ein Pfad eine reguläre Datei (-f), ein Verzeichnis (-d), ein symbolischer Link (-L) usw.
• ist eine Datei nicht leer (-s)
• ist eine Datei neuer/älter (mtime) als eine andere (-nt/-ot)
• ist ein Dateideskriptor ein Terminal (-t)
• wird eine Zeichenkette (in dem aktuellen Locale) lexikalisch vor (<) oder nach (>) einer anderen sortiert

werden v. a. die eingebauten Befehle (builtins) [ / test und das reservierte Wort [[ verwendet. [ ist fast identisch zu test (beide existieren auch als externe Kommandos); der einzige Unterschied ist, dass das letzte Argument ein ] sein muss, damit das Kommando wie ein Klammer-Ausdruck aussieht, den man aus anderen Programmiersprachen kennt (dort allerdings mit runden Klammern):

if [ "$var" = 'yes' ]; then
    echo foo
fi

if ! [ -v 'HOME' ]; then
    echo "Die Variable '\$HOME' existiert nicht."
fi

if ! [ -d "$HOME" ]; then
    echo "Das Verzeichnis '${HOME}' existiert nicht."
fi

if ! [ 'datei_1' -nt 'datei_2' ] && [ -f 'datei_2' ]; then
    echo "Die Datei 'datei_1' ist neuer als die Datei 'datei_2'."
fi

if [ "$var" = 'yes' ]; then ist äquivalent zu if test "$var" = 'yes'; then.

[ und test sind für die Bash-Syntax und -Grammatik ganz normale Kommandos. Die einzelnen Elemente müssen also getrennte Wörter sein und (ggf.) mit Quoting geschützt werden: test "$var" = 'foo bar' statt test $var='foo bar'.

Die beiden Kommandos und die meisten der genannten Operatoren sind in POSIX standardisiert. Im Gegensatz zu diesen beiden Kommandos ist [[ ein reserviertes Wort der Bash, weswegen zwischen [[ und ]] eine andere Bash-Grammatik gilt als normalerweise:

• Word-Splitting und Pathname-Expansion werden nicht angewendet.
• Diverse Metacharacters und Control-Operators müssen nicht mit Quoting geschützt werden und haben teils eine andere Bedeutung: <, >, &&, ||, (, )
• Quoting ändert die Bedeutung von ! von Negation auf literales Zeichen.

Operatoren für [[:

• [[ ... ]] versteht alle Operatoren, die [ und test verstehen.
• [[ ... ]] hat einen zusätzlichen Operator (den [ und test nicht haben): =~ für erweiterte reguläre Ausdrücke.
• Der Operator = (oder äquivalent: ==) hat eine andere Bedeutung als bei [ und test: Das Wort auf der rechten Seite wird wie extglob-Pattern-Matching interpretiert.
• Die Operatoren && und || funktionieren innerhalb von [[ ... ]] ähnlich wie ansonsten zwischen Kommandos, aber in diesem Fall verbinden sie Tests.

In beiden Varianten ([[/[) sind mehrere Tests pro Kommando möglich. Allerdings ist dies nur bei [[ eindeutig. Wenn man [ verwendet, sollte man pro Test ein [-Kommando verwenden und diese Kommandos mit && oder || (oder if) verbinden.

$ if [ -d "$HOME" ] && [ "$HOME" != "${HOME#/home/}" ]; then echo 'normales Homeverzeichnis'; fi

$ if [[ -d $HOME && $HOME = /home/* ]]; then echo 'normales Homeverzeichnis'; fi

if list; then list; [ elif list; then list; ] ... [ else list; ] fi Der Teil zwischen if/elif und then entscheidet darüber, ob ein bzw. welcher Zweig ausgeführt wird. Dies kann ein beliebiges Kommandokonstrukt sein:

• einfaches Kommando
• Pipeline
• eingebautes Kommando (builtin)
• Shellfunktion (function)
• Kommando-Liste (UND, ODER, unbedingte Folge)
• verbundenes Kommando (inklusive eines weiteren if-Konstrukts)

Die Entscheidung, ob die Bedingung wahr ist, hängt an dem Exit-Status des Kommandos. Die einfachste Variante ist if true; then echo foo; fi. Mit elif kann man alternative Bedingungen testen:

if list; then
    # Falls die Bedingung wahr ist, wird dies ausgeführt.
    echo foo
elif list; then
    # Falls die erste Bedingung falsch ist, aber die zweite wahr, dann wird dies ausgeführt.
    echo bar
fi

Mit else kann man einen Zweig auswählen, falls alle Bedingungen falsch sind.

if list; then
    # Falls die Bedingung wahr ist, wird dies ausgeführt.
    echo foo
else
    # Falls die Bedingung falsch ist, wird dies ausgeführt.
    echo bar
fi