bash

Um mit dem Betriebssystem zu interagieren, und teilweise auch, damit das Betriebssystem selbst arbeiten kann, bedarf es eines Interpreter-Programms, das die eingegebenen Befehle an das System weiterreicht. Unter Unix, und unix-verwandten Systemen wird dieser Kommandozeileninterpreter Shell genannt. Unter Arch ist diese Shell standardmäßig die Bash.

Über die bash

Wenn man ein System installiert, installiert man auch gleich die bash mit, da sie ein wichtiger Teil des Systems ist. Um nach dem Einloggen zu sehen, welche Shell man gerade benutzt, kann man sich zum Beispiel folgenden Befehls bedienen:

ps -o cmd= -p $$

„ps“ listet Prozesse auf, „-o cmd=“ definiert, dass nur der Prozessname angezeigt werden soll, und „-p“ definiert, dass nur der Prozess angezeigt werden soll, dessen Prozess-ID man angibt. „$$“ gibt die ID des aktuellen Prozesses zurück. Da die Shell ebenfalls als Prozess gesehen wird, gibt „$$“ die Prozess-ID der Shell zurück, in der man sich gerade befindet.

ps -o cmd= -p $$

bash

Wenn man nun wissen will, welche bash-Version man verwendet, bedient man sich des Parameters „--version“

bash --version

GNU bash, version 3.2.48(1)-release (i686-pc-linux-gnu)
Copyright (C) 2007 Free Software Foundation, Inc.

Die Bash gilt generell als sehr komplex, und wird von einigen Anwendern auch als etwas unhandlich beschrieben, ist allerdings dennoch quasi die Standard-Shell unter Linux. Sie ist vollständig zur „Original-Shell“ (sh) kompatibel und unterstützt viele Befehle der Korn-Shell (ksh) und der Z-Shell (zsh).

Verwendung

Wie bereits angesprochen ist die bash die Standard-Shell unter Arch. Von daher bedarf es keiner sonderlichen Maßnahmen, um die Bash zu verwenden, einfaches einloggen reicht. Unter grafischen Umgebungen erreicht man die bash über einen Terminalemulator.

Um die bash explizit zu starten, benutzt man einfach den Befehl „bash“, nachfolgende Befehlsfolge verdeutlicht dies.

$ echo $$ # Die PID der aktuellen Shell ausgeben
5450
$ bash
$ echo $$
5711
$ exit
exit
$ echo $$
5450
$

Zuerst wird die Prozess-ID der aktuellen Shell angezeigt, dann wird die bash gestartet, und die Prozess-ID erneut angezeigt, dies ist nun eine andere als beim ersten Mal, da man sich ja nicht mehr in der ersten bash befindet. Die bash wird dann verlassen, und man befindet sich wieder in der bash, mit der man angefangen hat.

Da die bash selbst ja ein Kommandointerpreter ist, bietet sie selbst keine eigenen Programmfunktionen, außer eben dem Interpretieren und Weiterreichen von Befehlen, und dem Zurückreichen des Ergebnisses. Allerdings lässt sich die bash durch viele Skripte, Parameter, und Konfigurationen – zum Beispiel in der bashrc – stark an die eigenen Bedürfnisse anpassen.

Beispiele

Nachfolgend drei praxisnahe Beispielverwendungen der verschiedenen bash-Aufrufe. In dem Wiki-Artikel zur .bashrc sind weitere Beispiele aufgeführt, die zeigen, wie man sich die bash anpassen kann.

Shellscript

Wenn man ein Shellscript schreibt, kann man am Anfang der Datei mit dem sogenannten „Shebang“ bestimmen, dass die bash verwendet werden soll.

#!/bin/bash
echo $$

… dann der Aufruf …

$ echo $$
6577
$ chmod +x script
$ ./script
6604
$ echo $$
6577
$

Für das Script wird eine eigene Bash gestartet, innerhalb dieser das Script dann abgearbeitet wird. Nach Beendigung des Scriptes wird diese bash wieder verlassen.

Befehlsübergabe

Anstatt mittels Shellscript kann man an die bash beim Aufruf auch Befehle übergeben, die dann im Kontext dieser bash abgearbeitet werden. Danach wird die bash wieder verlassen.

$ echo $$
6222
$ bash -c 'echo $$'
6240
$ echo $$
6222
$

Im Kontext der aufgerufenen Bash wird der echo-Befehl ausgeführt. Wenn man die Angabe nach „-c“ in doppelte Anführungszeichen setzen würde, würde die bash diese vor dem Aufrufen schon bearbeiten, und „$$“ durch die aktuelle Prozess-ID ersetzen. Durch die einfachen Anführungszeichen wird der Befehl ungeparst übergeben.

Andere Konfigurationsdateien

Vermutlich hat man sich seine bash durch die Standard-Konfigurationsdateien angepasst. Wenn man nun etwas testen möchte, und sichergehen will, dass dies auch ohne die eigenen Anpassungen funktioniert, ruft man sich eine bash auf, wo dies deaktiviert ist.

$ myip
91.00.00.51
$ bash --norc --noprofile
$ myip
bash: myip: command not found
$ exit
exit
$ myip
91.00.00.51
$

Mit diesem Aufruf werden sowohl die Datei „.bashrc“ als auch die Datei „.bash_profile“ ignoriert, welche bei mir nichts weiter macht, als die „.bashrc“ auszuführen.

Man kann sich auch eine weitere „.bashrc“ anlegen, und der bash mittels Parameter mitteilen, diese, anstatt der Standard-Datei zu verwenden.

$ bash -rcfile /pfad/zur/rc-datei

Nützliche Shortcuts

`ESC` + Taste	Funktion
`ESC` `d`	löschen von der Cursorposition aus bis zum Ende des Wortes
`ESC` `f`	Cursor ein Wort vor
`ESC` `b`	Cursor ein Wort zurück
`ESC` `t`	Zwei nebeneinander stehende Wörter gegeneinander austauschen. (Bar Foo wird zu Foo Bar)
`Tab ↹` + `Tab ↹`	Funktion
`Tab ↹` `Tab ↹`	listet alle verfügbaren Befehle auf
/ `Tab ↹` `Tab ↹`	listet alle verfügbaren Verzeichnisse auf (z.B.: /etc/ `Tab ↹Tab ↹`würde alle in /etc/ verfügbaren Verzeichnisse auflisten)
~ `Tab ↹` `Tab ↹`	zeigt alle System Nutzer an
$ `Tab ↹` `Tab ↹`	Liste aller Systemvariablen
@ `Tab ↹` `Tab ↹`	zeigt Hosts an
= `Tab ↹` `Tab ↹`	hat den selben Effekt wie `ls`
`ALT` + Taste	Funktion
`ALT` `<`	zeigt die erste Zeile in der bash history an
`ALT` `>`	zeigt die letzte Zeile in der bash history an
`ALT` `.`	fügt das letzte Argument an das Kommando an
`ALT` `b`	bewegt den Cursor ein Wort rückwärts
`ALT` `f`	bewegt den Cursor ein Wort vorwärts
`ALT` `t`	Tauscht zwei nebeneinanderstehende Wörter gegeneinander (Bar Foo wird Foo Bar)
`ALT` `u`	wandelt ein Wort von Kleinbuchstaben in Großbuchstaben um ($display wird zu $DISPLAY)
`ALT` `l`	wandelt ein Wort von Großbuchstaben in Kleinbuchstaben um (ECHO wird zu echo)
`ALT` `c`	wandelt den Anfangsbuchstaben von Kleinbuchstaben in Großbuchstaben um (verzeichnisname wird zu Verzeichnisname)
`ALT` `← Löschen`	löscht ein komplettes Wort rückwärts
`STRG` + Taste	Funktion
`STRG` `a`	bewegt den Cursor zum Zeilenanfang
`STRG` `e`	bewegt den Cursor zum Zeilenende
`STRG` `k`	löscht alles von der Cursorposition bis Zeilenende
`STRG` `u`	löscht alles von der Cursorposition bis Zeilenanfang
`STRG` `w`	löscht vorangegangenes Wort (foo bar wird foo )
`STRG` `t`	vertauscht zwei Buchstaben gegeneinander (foobra wird foobar)
`STRG` `y`	stellt zuletzt gelöschtes wieder her, bzW. fügt es ein
`STRG` `d`	löscht ein Zeichen unter dem Cursor
`STRG` `h`	löscht ein Zeichen vor dem Cursor
`STRG` `f`	bewegt den Cursor vorwärts
`STRG` `b`	bewegt den Cursor rückwärts
`STRG` `r`	findet eine Buchstabensequenz in der History
`STRG` `s`	sperrt die Eingabe
`STRG` `q`	entsperrt die Eingabe wieder
`STRG` `l`	hat den selben Effekt wie `clear`
Diverses	Funktion
foobar `!!`	stellt dem zuvor abgesetzten Kommando foobar voran. (`pacman -Syu` wird `sudo pacman -Syu`)
`^`foo`^`bar	ersetzt das erste auftauchende foo im zuvor abgesetzten Kommando durch bar. (`ls /home/foo/foo/` wird `ls /home/bar/foo/`).

Bash History Suggest Box

hstr^AUR ist eine Erweiterung für die Bash, da die eingebaute History-Funktion, die mit STRG R erreicht wird, nicht für einige Anwender nicht ausreichend sein könnte.

Mit dem Befehl hh lässt sich das Programm einfach starten. Darauf hin wird die History angezeigt und man kann wie gewohnt mit den Pfeiltasten durchblättern. Ein Suchmuster kann natürlich auch genutzt werden und um das Kommando vor dem Ausführen noch zu modifizieren zu können, kann die Tab ↹ oder eine der Pfeiltasten links, rechts genutzt werden.

Siehe auch

Weblinks