|
|
(121 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) |
Zeile 1: |
Zeile 1: |
| = Beschreibung =
| | '''Builtins''' - Kommandos, die von der Shell bereitgestellt werden |
| Es liegt wohl in der Natur des Linux-Neulings, seine Testprogramme und -skripten «"test« zu benennen (eigentlich kann ich mich an keinen Linuxkurs erinnern, indem nicht mindestens einer der Teilnehmer auf diese Weise mit den builtin Kommandos der Bash konfrontiert wurde).
| |
|
| |
|
| Nach verrichteter Arbeit zeigte der Testlauf:
| | == Beschreibung == |
| '''ls -l test'''
| | ; Kommandos, die von der Shell bereitgestellt werden |
| -rwxr-xr-x 1 user users 12177 Sep 23 10:52 test
| | * Eingebaute Befehle (Builtins) |
| '''test'''
| | * Kein eigener Prozess |
| | * Von der Shell interpretiert und ausgeführt |
|
| |
|
| Mit Kenntnis des Vorgehens der Bash bei der Suche nach einem Kommando, gelangt man bald zum Schluss, dass sich ein builtin Kommando vorgedrängelt hat.
| | ; Intern/Extern |
| | Manchmal gibt es eine eingebaute und eine externe Version |
| | 'echo' (intern) und '/bin/echo' (extern) |
|
| |
|
| Es gibt eine Fülle solcher eingebauter Kommandos und mindestens 4 Gründe, warum solche in der Bash überhaupt existieren: # Weil es ein solches Kommando in Unix nicht gibt (Beispiel "source")
| | === Gründe für eingebauten Befehlen === |
| # Weil ein builtin Kommando effizienter arbeitet, als ein externes Kommando (keine Prozesserzeugung notwendig; Beispiel »echo«) | | # Befehl nicht als Unix-Kommando verfügbar |
| # Weil nur ein eingebautes Kommando Bash-interne Variablen ändern kann (Beispiel »export«) | | #* Beispielsweise ''source'' |
| # Weil ein Kommando wie »exec« nur innerhalb der Bash realisierbar ist | | # Weil ein builtin Kommando effizienter arbeitet |
| | #* als ein externes Kommando (keine Prozesserzeugung notwendig; Beispiel »echo«) |
| | # Weil nur ein eingebautes Kommando Bash-interne Variablen ändern kann (Beispiel »export«) |
| | # Weil ein Kommando wie »exec« nur innerhalb der Bash realisierbar ist |
|
| |
|
| Betrachten wir die einzelnen builtin-Kommandos:
| | === Arten von builtin === |
| * Etliche der besprochenen Shell-Kommandos starten nicht, wie sonst üblich, einen eigenen Prozeß, sondern sie werden direkt von der Shell interpretiert und ausgeführt.
| |
| * Teilweise ist keine E/A-Umleitung möglich. Etliche Kommandos der folgenden Auswahl wurden schon besprochen.
| |
| * Andere werden weiter unten behandelt. Zum Teil gibt es interne und externe Versionen, z. B. 'echo' (intern) und '/bin/echo' (extern).
| |
|
| |
|
| {|class="wikitable sortable" | | === Was wird gestartet? === |
| | * [[type]] |
| | * [[whereis]] |
| | |
| | === Builtins ein- und ausschalten === |
| | |
| | == Übersicht == |
| | {| class="wikitable sortable" |
| | |- |
| | ! Befehl !! Beschreibung |
| | |- |
| | | [[Null]] || |
| |- | | |- |
| | | '''break''' | | | [[source]] || |
| | | Schleife verlassen | |
| |- | | |- |
| | | '''continue''' | | | [[alias]] || Definition einer Abkürzung für ein Kommando |
| | | Sprung zum Schleifenanfang | |
| |- | | |- |
| | | '''echo''' | | | [[jobs]] || Listet die Jobnummern aller Hintergrundprozesse auf |
| | | Ausgabe | |
| |- | | |- |
| | | '''eval''' | | | [[bind]] || |
| | | Mehrstufige Ersetzung | |
| |- | | |- |
| | | '''exec''' | | | [[break]] || |
| | | Überlagerung der Shell durch ein Kommando | |
| |- | | |- |
| | | '''exit''' | | | [[cd]] || Verzeichnis wechseln |
| | | Shell beenden | |
| |- | | |- |
| | | '''export''' | | | [[command]] || |
| | | Variablen für Subshells bekannt machen | |
| |- | | |- |
| | | '''read''' | | | [[compgen]] || |
| | | Einlesen einer Variablen | |
| |- | | |- |
| | | '''shift''' | | | [[complete]] || Verhalten der Bash bei der Vervollständigung steuern |
| | | Parameterliste verschieben | |
| |- | | |- |
| | | '''trap''' | | | [[continue]] || |
| | | Behandlung von Signalen | |
| |- | | |- |
| |} | | | [[declare]] || Deklarieren von Variablen |
| | | |- |
| * Bei der Suche nach Kommandos betrachtet die Shell Aliasse und Funktionen noch vor den eingebauten Kommandos. Überdeckt nun ein solcher Name ein builtin-Kommando, so wird beim einfachen Aufruf immer der Alias bzw. die Funktion ausgeführt werden.
| | | [[dirs]] || Anzeige des Verzeichnisstacks |
| * Mit vorangestelltem builtin weist man nun die Bash an, auf jeden Fall ihr eingebautes Kommando aufzurufen.
| | |- |
| * Der Rückgabestatus ist gleich dem Rückgabewert des Builtin's oder "falsch", falls das Kommando kein builtin ist.
| | | [[disown]] || |
| | | |- |
| = Null - Kommando =
| | | [[echo]] || Eine Zeile Text anzeigen |
| ''':'''
| | |- |
| * Das Null-Kommando tut nichts, außer den Rückgabewert 0 zu erzeugen
| | | [[enable]] || Eingebauten Kommandos der Shell aktivieren |
| ** 0 ist der übliche Rückgabewert eines Kommandos, wenn seine Ausführung erfolgreich war
| | |- |
| * Nützlich ist es in Shellskripten, falls Sie in Bedingungen einen wahren Wert (»true«) benötigen oder an Positionen, wo syntaktisch ein Kommando erwartet wird, Sie aber keines benötigen:
| | | [[eval]] || Liest seine Argumente, wobei die üblichen Ersetzungen stattfinden, und führt die resultierende Zeichenkette als Kommando aus. |
| | | |- |
| $ '''while : ;do echo "Eine Endlosschleife"; done'''
| | | [[exec]] || Das Kommando besitzt zwei Bedeutungen. |
| Eine Endlosschleife
| | |- |
| Eine Endlosschleife
| | | [[exit]] || Beendet die Shell |
| Eine Endlosschleife
| | |- |
| ...
| | | [[export]] || Exportieren von Variablen |
| Eine Endlosschleife[Strg]+[C]
| | |- |
| '''if test -a foo ; then :; else echo "Datei nicht existent"; fi'''
| | | [[fc]] || Manipulation der History-Einträge |
| Datei nicht existent
| | |- |
| | | | [[fg]] || holt einen Hintergrundprozess in den Vordergrund |
| = source =
| | |- |
| Die angegebene Datei wird gelesen und innerhalb der Shellumgebung ausgeführt.
| | | [[getopts]] || |
| | | |- |
| Ist die Datei ohne Pfad angegeben, wird dabei in Verzeichnissen der PATH-Variable gesucht.
| | | [[hash]] || |
| | | |- |
| Wird sie dort nicht gefunden, wird das aktuelle Verzeichnis betrachtet. Das Kommando kann sich der C-Programmierer als "include" der Bash vorstellen.
| | | [[help]] || Schreibt einen kurzen Hilfetext zu einem eingebauten Kommando aus. |
| | | |- |
| Manche Linuxdistributionen (bspw. RedHat) verwenden dieses Kommando in ihren Runlevel-Skripten, um eine Funktionsbibliothek einzubinden.
| | | [[history]] || Kommandozeilenspeicher anzeigen |
| | | |- |
| Auf der Kommandozeile bietet sich "source" an, um die initiale Umgebung zu rekonstruieren (weil man u.U. die Umgebungsvariablen "verbogen" hat):
| | | [[kill]] || Signale an Prozesse senden |
| | | |- |
| $ '''source /etc/profile'''
| | | [[let]] || Für jedes Argument wird eine arithmetische Substitution versucht |
| # bzw.
| | |- |
| '''. /etc/profile'''
| | | [[local]] || Definition lokaler Variablen |
| | | |- |
| = alias =
| | | [[logout]] || Beendet eine Login-Bash und meldet den Benutzer ab. In einer Nicht-Login-Bash wird eine Fehlermeldung ausgegeben. |
| Dient der Definition einer Abkürzung für ein(e) Kommando(folge). Mit der Option -p werden alle vorhandenen Aliasse aufgelistet; Beispiele wurden bereits im einleitenden Abschnitt zu Bash (Eingabehilfen) und in Allgemeines zu Shells genannt.
| | |- |
| | | | [[popd]] || Entfernt den obersten Eintrag vom Verzeichnisstack und wechselt zum neuen obersten Verzeichniseintrag. |
| = jobs =
| | |- |
| Listet die Jobnummern aller Hintergrundprozesse auf.
| | | [[printf]] || |
| | | |- |
| = bind =
| | | [[pushd]] || Mit dem Kommando kann in ein angegebenes Verzeichnis gewechselt werden, wobei das Verzeichnis auf einem Stack abgelegt wird |
| siehe [[Linux:Shell:Bash:Builtin:bind]]
| | |- |
| | | | [[pwd]] || Gibt das aktuelle Arbeitsverzeichnis aus |
| = break =
| | |- |
| break [n]
| | | [[read]] || |
| * Dient zum expliziten Verlassen einer Schleife.
| | |- |
| * Ohne Angabe eines Arguments wird die unmittelbar umgebende Schleife verlassen
| | | [[readonly]] || Variablen und Funktionen lassen sich nachträglich als »nicht änderbar« deklarieren. |
| * möchte man tiefere Verschachtelungen verlassen, muss die Tiefe angegeben werden:
| | |- |
| ...
| | | [[return]] || Rücksprung aus einer Funktion |
| while [ Bedingung ]; do
| | |- |
| for i in Liste; do
| | | [[set]] || Setzen bash-interner Variablen |
| case "$i" in
| | |- |
| foo*) break;
| | | [[shift]] || Verschieben der Positionsparameter |
| bla*) tue etwas ;;
| | |- |
| *) Fehler; break 2;
| | | [[shopt]] || Dient zum Setzen bash-interner Variablen, die das Verhalten der Shell maßgeblich beeinflussen |
| esac
| | |- |
| done
| | | [[suspend]] || Suspendiert die Shell. Sie kann nur durch ein Signal SIGCONT reaktiviert werden. |
| done
| | |- |
| ...
| | | [[test]] || Bedingungen prüfen |
| | | |- |
| Die Syntax der break-Anweisung lautet wie folgt:
| | | [[time]] || Report time consumed by pipeline's execution |
| break [ n ]
| | |- |
| | | | [[times]] || Zeit der Shell und von ihr gestarteter Kommandos messen |
| Mit break kann man die innerste Ebene (bzw. n Schleifenebenen) verlassen ohne den Rest der Schleife auszuführen.
| | |- |
| | | | [[trap]] || |
| = cd =
| | |- |
| siehe [[Linux:Shell:Bash:Builtin:cd |Verzeichnis wechseln]]
| | | [[type]] || |
| | | |- |
| = command =
| | | [[typeset]] || declare |
| * Ein weiterer Weg, um die Verwendung von Aliassen oder Funktionen bei der Suche nach einem Kommando temporär auszuschalten, ist ein dem zu startenden Kommandonamen voranzustellendes command
| |
| * Die Shell sucht nun einzig in der Liste der eingebauten Kommandos und den Pfaden aus PATH
| |
| * Hilfreich ist die Option -p, falls die PATH-Variable einmal "völlig daneben" belegt ist
| |
| ** die Bash sucht in default-Pfaden und findet so zumindest die wichtigsten Programme.
| |
| | |
| = compgen =
| |
| Mit dem Kommando lassen sich die möglichen Expansionen anzeigen. Um bspw. gezielt die denkbaren Erweiterungen aller mit "l" beginnenden Aliasse zu erhalten, ist folgende Kommandozeile notwendig:
| |
| | |
| $ '''compgen -A alias l'''
| |
| l
| |
| la
| |
| ll
| |
| ls
| |
| ls-l
| |
| | |
| Anstatt von "alias" können u.a. Funktionen ("function"), Schlüsselworte der Bash ("keywords"), Dateinamen ("file"), Verzeichnisse ("directory"), Variablen ("variable") expandiert werden. Noch weit reichender sind die Möglichkeiten in Bezug auf Dateinamen, da hier mit Suchmustern gearbeitet werden kann:
| |
| | |
| $ '''compgen -G '*c*''''
| |
| Packages
| |
| bla.xcf
| |
| countdir
| |
| linuxbuch
| |
| Documents
| |
| | |
| Abgesehen von -r und -r verwendet compgen dieselben Optionen wie das nachfolgend beschriebene complete.
| |
| | |
| = complete =
| |
| Mit diesem Kommando kann das ganze Verhalten der Bash bei der Vervollständigung von Argumenten verändert werden
| |
| * siehe [[Linux:Shell:Bash:Builtin:complete]]
| |
| | |
| = continue =
| |
| Die Syntax der continue-Anweisung lautet wie folgt:
| |
| continue [ n ]
| |
| | |
| Man benutzt continue um die restlichen Befehle in einer Schleife zu überspringen und mit dem nächsten Schleifendurchlauf anzufangen.
| |
| | |
| Wenn der Parameter n angegeben wird, werden n Schleifenebenen übersprungen.
| |
| '''continue [n] '''
| |
| | |
| Dieses Kommando kann innerhalb von Schleifen verwendet werden, um unmittelbar mit dem nächsten Schleifendurchlauf fortzufahren.
| |
| | |
| Ohne Angabe von "n" ist die umgebende Schleife gemeint; mit Angabe einer ganzen Zahl "n" kann im Falle von verschachtelten Schleifen diejenige benannt werden, die zu durchlaufen ist
| |
| | |
| for i in $(ls); do
| |
| test -d $i && continue
| |
| # tue etwas...
| |
| done
| |
| | |
| = declare =
| |
| Zum Deklarieren von Variablen, wobei diese gleichzeitig mit Attributen versehen werden können; siehe unter Variablen
| |
| | |
| = dirs =
| |
| Dient zur Anzeige des Verzeichnisstacks. in Verzeichnis kann neben dem bekannten Kommando cd auch mit dem eingebauten Kommandos pushd bzw. popd gewechselt werden.
| |
| | |
| Bei letzterem Vorgehen wird das Verzeichnis auf einem Stack abgelegt, dessen Einträge popd in umgekehrter Reihenfolge entfernt und in das jeweilige Ausgangsverzeichnis wechselt.
| |
| | |
| = disown =
| |
| siehe [[Linux:Shell:Bash:Builtin:disown]]
| |
| | |
| = echo - Eine Zeile Text anzeigen =
| |
| | |
| * siehe [[Linux:Shell:Bash:Builtin:echo]]
| |
| * siehe [[Linux:Befehl:echo]]
| |
| | |
| = enable =
| |
| * Die eingebauten Kommandos der Shell lassen sich bei Bedarf aktivieren oder auch abschalten.
| |
| * Letzteres kann nützlich sein, wenn Sie fortwährend auf ein externes Kommando zugreifen müssen, das denselben Namen wie ein Shell-Builtin besitzt.
| |
| * Da die Shell immer ihr eigenes Kommando bevorzugt, müssten Sie ständig den vollständigen Pfad eintippen - auf die Dauer ein lästiges Unterfangen.
| |
| * Mit -n <Kommando> deaktivieren Sie das Builtin; ohne Eingabe einer Option lässt es sich wieder aktivieren.
| |
| | |
| = eval =
| |
| * Das Kommando eval liest seine Argumente, wobei die üblichen Ersetzungen stattfinden, und führt die resultierende Zeichenkette als Kommando aus.
| |
| *siehe [[Linux:Shell:Bash:Builtin:eval]]
| |
| | |
| = exec =
| |
| * Das Kommando besitzt zwei Bedeutungen.
| |
| * siehe [[Linux:Shell:Bash:Builtin:exec]]
| |
| | |
| = exit =
| |
| Wie schon bei der interaktiven Shell kann auch eine Shell-Skript mit exit abgebrochen werden.
| |
| | |
| Vom Terminal aus kann mit der DEL-Taste abgebrochen werden, sofern das Signal nicht abgefangen wird (siehe trap). Die Syntax der exit-Anweisung lautet wie folgt:
| |
| | |
| exit [ n ]
| |
| | |
| Die exit-Anweisung wird benutzt, um ein Skript zu beenden. Wenn der Parameter n angegeben wird, wird er von dem Skript als Exit-Code zurückgegeben.
| |
| | |
| '''exit [n] '''
| |
| | |
| Beendet die Shell (das Shellskript) mit dem angegebenem Rückgabewert. Wird kein Wert angegeben, liefert exit den Status des letzten Kommandos.
| |
| | |
| = export =
| |
| Dient zum exportieren von Variablen und - mit der Option -f von Funktionen, so dass diese ab der (Shell)Prozess ihrer Definition auch in allen abgeleiteten Prozessen sichtbar sind ("globale Variablen").
| |
| | |
| Mit der Option -n kann die export-Eigenschaft entzogen werden. -p listet alle exportierten Variablen und Symbole auf:
| |
| | |
| PATH=$PATH:/usr/local/bin
| |
| export PATH
| |
| | |
| = fc =
| |
| Siehe unter Manipulation der History-Einträge
| |
| | |
| = fg [Job] =
| |
| | |
| Holt den angegebenen ("Jobnummer") bzw. den zuletzt gestarteten Hintergrundprozess in den Vordergrund.
| |
| | |
| = getopts =
| |
| siehe '''[[Linux:Shell:Bash:Builtin:getopts]]'''
| |
| | |
| = hash =
| |
| Ein auf der Kommandozeile angegebenes Kommando muss von der Shell gesucht werden.
| |
| | |
| Die Suche, vor allem wenn sie die Angaben aus PATH einschließt, kostet Zeit. Deswegen merkt sich die Bash die Zugriffspfade zu allen externen Kommandos in einer Hashtabelle.
| |
| | |
| Diese Hashtabelle wird zuerst konsultiert (es sei denn hashall ist nicht gesetzt; vergleiche set) und nur wenn der Pfad zu einem Kommando dort nicht erfasst wird, werden die Verzeichnispfade betrachtet.
| |
| | |
| Beim nächsten Zugriff auf dasselbe Kommando wird man den Geschwindigkeitszuwachs deutlich spüren.
| |
| | |
| Zur Anzeige der Hashtabelle ist »hash« ohne Angabe von Argumenten aufzurufen:
| |
| | |
| hash
| |
| hits command
| |
| 2 /bin/ls
| |
| 1 /bin/mv
| |
| 6 /bin/sh
| |
| 8 /usr/bin/vi
| |
| 1 /bin/chmod
| |
| 3 /bin/date
| |
| 1 /usr/bin/id
| |
| 1 /usr/bin/man
| |
| | |
| Ein Problem besteht nun mit gleichnamigen Kommandos. Liegt eines in der Hashtabelle vor, so kann auf das andere nur über die vollständige Pfadangabe zugegriffen werden.
| |
| | |
| Soll dieses "benachteiligte" Kommando nun vermehrt eingesetzt werden, ist ein Löschen der Hashtabelle mittels »-r« sinnvoll:
| |
| | |
| hash -r
| |
| hash
| |
| hash: hash table empty
| |
| | |
| Indem »hash« mit einem oder mehreren Kommandonamen aufgerufen wird, werden diese Kommandos gesucht und in die Hashtabelle aufgenommen; sie werden jedoch nicht gestartet (sinnvoll ist dies eventuell in Startskripten).
| |
| | |
| Des Weiteren kann mit »-p <Pfad_zum_Kommando>« ein solches mit vorgegebenem Pfad der Tabelle hinzufügen.
| |
| | |
| = help =
| |
| Schreibt einen kurzen Hilfetext zu einem eingebauten Kommando aus. | |
| | |
| = history =
| |
| Das Kommando dient zur Anzeige oder Manipulation des Kommandozeilenspeichers.
| |
| | |
| Ohne Optionen gerufen, werden alle Einträge der Liste inklusive einer Zeilennummerierung aufgeführt; mit einer vorangestellten Zahl kann die Darstellung auf die letzten Einträge eingeschränkt werden:
| |
| | |
| '''history 5'''
| |
| 555 parseline -aF -f
| |
| 556 parseline -f bla -l huch
| |
| 557 mv parseline Scripts\&Programs/
| |
| 558 ll Linuxfibel/bash.htm
| |
| 559 history 5
| |
| | |
| Anhand der Nummerierung kann nun gezielt ein Eintrag entfernt werden (»-d <Nummer>«). »-c« löscht den gesamten Inhalt.
| |
| | |
| Der Kommandozeilenspeicher wird bei Beendigung der Shell in einer Datei gesichert, um diese explizit zu aktualisieren, kann »-a« bzw. »-w« genutzt werden, womit die neuen Einträge angehangen werden bzw. der alte Inhalt ersetzt wird.
| |
| | |
| = jobs =
| |
| Das Kommando zeigt die in der Jobtabelle erfassten Jobs (Hintergrundprozesse) an.
| |
| | |
| Das Format der Ausgabe kann über Optionen gesteuert werden; im Zusammenhang mit Prozessen gehen wir weiter unten auf dieses Thema ein.
| |
| | |
| = kill =
| |
| Das Kommando dient der Steuerung bereits laufender Prozesse, indem es an diese Signale versendet.
| |
| | |
| Während einige Signale vordefinierte Bedeutungen besitzen, können andere von den Prozessen nach eigenen Vorstellungen behandelt werden.
| |
| | |
| Das Versenden von Signalen soll auch im Zusammenhang mit Prozessen diskutiert werden.
| |
| | |
| = let =
| |
| Für jedes Argument wird eine arithmetische Substitution versucht. | |
| | |
| Expandiert das letzte Argument zu 0, ist der Rückgabewert 1; sonst immer 0. »let« bietet somit eine Möglichkeit der Überprüfung, ob eine Variable eine Zahl >0 enthält:
| |
| | |
| '''failure=1234x
| |
| let $failure 2>/dev/null || echo "keine Zahl"'''
| |
| keine Zahl
| |
| '''let answer=6*7'''
| |
| 42
| |
| | |
| = local =
| |
| Das Kommando kann nur innerhalb von Funktionen verwendet werden und dient der Definition lokaler Variablen. Somit ist sichergestellt, dass existierende Variablen gleichen Namens nichtversehentlich überschrieben werden:
| |
| | |
| '''var=foo
| |
| func() { var=bla; echo $var; }
| |
| func'''
| |
| bla
| |
| '''echo $var'''
| |
| bla
| |
| '''var=foo
| |
| func() { local var=bla; echo $var; }
| |
| func'''
| |
| bla
| |
| '''echo $var'''
| |
| foo
| |
| | |
| = logout =
| |
| * Beendet eine Login-Bash und meldet den Benutzer ab.
| |
| * In einer Nicht-Login-Bash hagelt es eine Fehlermeldung.
| |
| | |
| = popd =
| |
| * Entfernt den obersten Eintrag vom Verzeichnisstack und wechselt zum neuen obersten Verzeichniseintrag. Dieser Wechsel kann mit der Option »-n« unterdrückt werden.
| |
| * Um einen anderen Eintrag als den obersten zu entfernen, kann dieser mit »+Anzahl« angegeben werden.
| |
| * Der oberste Verzeichniseintrag selbst ist »+0«, der zweite »+1« usw.
| |
| * Mit »-Anzahl« beginnt die Zählung am unteren Ende des Stacks.
| |
| * Ein Beispiel zur Anwendung folgt beim korrespondierenden »pushd«.
| |
| | |
| = printf =
| |
| printf "FORMAT" Argument[e]
| |
| | |
| * Das Kommando verhilft zu einer formatierten Ausgabe analog zum printf der Programmiersprache C.
| |
| * Die FORMAT-Zeichenkette enthält hierfür Platzhalter mit optionalen Ausrichtungsparametern; die nachfolgenden Argumente müssen vom Typ her genau dem Typ des Platzhalters entsprechen.
| |
| * Innerhalb der FORMAT-Zeichenkette können Escape-Sequenzen verwendet werden.
| |
| * Die wichtigsten sind »\n« (Zeilenumbruch), »\t« (Tabulator) und »\a« (akustisches Zeichen).
| |
| * Ein Platzhalter besitzt die Form »%[Ausrichtung]Symbol«, wobei die Ausrichtung eine Zahl ist, die die Anzahl darzustellender Zeichen des Arguments betrifft.
| |
| * Ist das Argument länger, werden die überschüssigen Zeichen abgeschnitten, ist es kürzer, werden Leerzeichen aufgefüllt.
| |
| * Mit einem optionalen Minus »-« vor der Zahl wird das Argument linksbündig angeordnet.
| |
| | |
| Wichtige Symbole sind:
| |
| {|class="wikitable sortable"
| |
| |- | | |- |
| | | d | | | [[ulimit]] || |
| | | Eine ganze Zahl | |
| |- | | |- |
| | | s | | | [[umask]] || Zugriffsrechte für neue Dateien steuern |
| | | Eine Zeichenkette | |
| |- | | |- |
| | | f | | | [[unalias]] || Löschen von Aliasen |
| | | Rationale Zahl; hierbei kann die Anzahl darzustellender Vor- und Nachkommastellen angegeben werden: "%8.3f" | |
| |- | | |- |
| | | E | | | [[unset]] || Löschen einer Variable oder Funktion |
| | | Darstellung rationaler Zahlen in Exponentenform. | |
| |- | | |- |
| | | [[wait]] || Warten auf einen oder alle Hintergrundprozesse |
| |} | | |} |
| '''Beispiele'''
| |
|
| |
| '''printf "Zeichenkette: %8s Zahl %d\n" test 42'''
| |
| Zeichenkette: test Zahl 42
| |
|
| |
| '''printf "Zeichenkette:\t%8s\tZahl %d\n" test 42'''
| |
| Zeichenkette: test Zahl 42
| |
|
| |
| '''printf "Zeichenkette:\t%-8s\tZahl %3.1E\n" test 42'''
| |
| Zeichenkette: test Zahl 4,2E+01
| |
|
| |
| = pushd =
| |
| Mit dem Kommando kann in ein angegebenes Verzeichnis gewechselt werden, wobei das Verzeichnis auf einem Stack abgelegt wird.
| |
|
| |
| Mit »-n« wird der Verzeichniswechsel verhindert, der Name des Verzeichnisses aber dennoch gespeichert. Dieser Stack kann rotiert werden, mit »-Anzahl« wird vom Ende des Stacks aus rotiert; mit »+Anzahl« vom Anfang.
| |
|
| |
| Das nachfolgende Beispiel zählt alle Unterverzeichnisse ausgehend vom Startverzeichnis, wobei popd und pushd Verwendung finden:
| |
| '''cat countdir'''
| |
| #!/bin/sh
| |
|
| |
| while :; do
| |
| for i in $(ls); do
| |
| test -d $i || continue
| |
| pushd -n $(pwd)/$i &>/dev/null
| |
| number=$(($number+1))
| |
| done
| |
| popd &>/dev/null && continue
| |
| break
| |
| done
| |
| echo Anzahl: $number
| |
|
| |
| = pwd =
| |
| * Gibt das aktuelle Arbeitsverzeichnis aus.
| |
| * Mit der der Option »-P« wird der Pfad ohne enthaltene symbolische Links angegeben; mit »-L« werden Links berücksichtigt.
| |
| * Beide Optionen sind sinnvoll, um die Einstellung der Variablen »physical« zu überschreiben:
| |
|
| |
| '''pwd'''
| |
| /usr/X11
| |
| '''pwd -P'''
| |
| /usr/X11R6
| |
| '''set -o physical
| |
| pwd'''
| |
| /usr/X11R6
| |
|
| |
| = read =
| |
| read Variable [Variable]
| |
|
| |
| * Mit »read« wird eine Eingabezeile eingelesen und deren Inhalt Variablen zugewiesen.
| |
| * Die Eingabe wird anhand der in IFS vorgegebenen Trennzeichen in einzelne Token zerlegt und der Reihe nach den Variablen zugewiesen.
| |
| * Stehen mehr Token zur Verfügung als Variablen, so wird die letzte Variable mit allen noch nicht zugewiesenen Token belegt
| |
| * stehen weniger Token bereit, bleibt der Inhalt der überschüssigen Variablen leer:
| |
|
| |
| '''read a b c'''
| |
| 1 2 3 4 5
| |
| '''echo "a=$a"; echo "b=$b"; echo "c=$c"'''
| |
| a=1
| |
| b=2
| |
| c=3 4 5
| |
|
| |
| * Ist die Anzahl erwarteter Token nicht vorhersehbar, bietet sich die Verwendung einer Feldvariablen an.
| |
| * Hierzu ist dem Variablennamen einzig die Option »-a« voranzustellen:
| |
|
| |
| '''read -a feld'''
| |
| Jedes Wort gelangt in ein eigenes Feld.
| |
| '''echo "3.Element: ${feld[2]}"'''
| |
| 3.Element: gelangt
| |
|
| |
| * Für die Shellprogrammierung sind zwei weitere Optionen nützlich.
| |
| * Zum einen »-p Prompt«, womit die erwartete Eingabe durch ein Prompt signalisiert wird und »-t Timeout«, wodurch das Kommando nach Ablauf der angegebenen Zeitspanne (Sekunden) mit einem Fehlerwert zurück kehrt:
| |
|
| |
| '''read -p "Eingabe: " -t 5 || echo "nichts gedrückt"'''
| |
| # Finger weg von der Tastatur!
| |
| Eingabe: nichts gedrückt
| |
|
| |
| = readonly =
| |
| * Variablen und Funktionen lassen sich nachträglich als »nicht änderbar« deklarieren.
| |
| * Um eine einfache Variable nur-lesend zu vereinbaren, genügt die Angabe ihres Namens; bezieht man sich auf eine Funktion, so ist »-f Funktionsname« anzugeben.
| |
| * Eine Feldvariable bewahrt die Option »-a Feldvariable« vor versehentlichem Überschreiben.
| |
| * Wird »readonly« ohne Angabe von Optionen oder Variablennamen aufgerufen, erhält man eine Auflistung aller »read-only«-Variablen und -Funktionen.
| |
|
| |
| = return =
| |
| return [n]
| |
|
| |
| * Dient zum Rücksprung aus einer Funktion.
| |
| * Mit [n] kann ein Rückgabewert vereinbart werden, ansonsten wird der Status des zuletzt innerhalb der Funktion ausgeführten Kommandos geliefert.
| |
|
| |
| = set =
| |
| [[Linux:Shell:Bash:Builtin:set | set dient zum Setzen bash-interner Variablen]]
| |
|
| |
| = shift =
| |
| shift [n]
| |
| * Dient zum Verschieben der Positionsparameter
| |
| * ohne weitere Angaben wird die Liste der Positionsparameter um eine Stelle nach links verschoben
| |
| * mit Angabe eine Ziffer wird um die spezifizierte Anzahl Stellen rotiert
| |
|
| |
| = shopt =
| |
| Dient zum Setzen bash-interner Variablen, die das Verhalten der Shell maßgeblich beeinflussen
| |
|
| |
| = suspend =
| |
| Suspendiert die Shell. Sie kann nur durch ein Signal SIGCONT reaktiviert werden.
| |
|
| |
| = test =
| |
| * '''test''' liefert in Abhängigkeit vom Wahrheitswert des Ausdrucks 0 (wahr) oder 1 (falsch) zurück und ist damit ein wichtiger Bestandteil vieler Shellskripten.
| |
| * siehe [[Linux:Shell:Bash:Builtin:test]]
| |
|
| |
| = times =
| |
| * Misst die Zeit für die Shell und der von dieser gestarteten Kommandos.
| |
|
| |
| Ausgegeben wird die User- und die Systemzeit (nicht jedoch die Realzeit, dies vermag das Kommando time):
| |
| times ls 0m0.090s 0m0.030s 0m0.160s 0m0.160s
| |
|
| |
| = trap =
| |
| siehe [[Linux:Shell:Bash:Builtin:trap]]
| |
|
| |
| = type =
| |
| siehe [[Linux:Shell:Bash:Builtin:type]]
| |
|
| |
| = typeset =
| |
| Siehe '''declare'''
| |
|
| |
| = ulimit =
| |
| siehe [[Linux:Shell:Bash:Builtin:ulimit]]
| |
|
| |
| = umask =
| |
| Setzt die Rechtemaske für neu erzeugte Dateien oder Verzeichnisse bzw. zeigt die Rechte an.
| |
|
| |
| Die Option -S veranlasst die Verwendung einer symbolischen anstatt der voreingestellten nummerischen Angabe:
| |
|
| |
| '''umask -S'''
| |
| u=rwx,g=rx,o=rx
| |
|
| |
| Weitere Beispiele finden Sie im Abschnitt Zugriffsrechte.
| |
|
| |
| = unalias =
| |
| Löscht den angegebenen Alias bzw. mit der Option -a alle Aliasse.
| |
|
| |
| = unset =
| |
| Dient zum Löschen einer Variable oder Funktion.
| |
|
| |
| = wait =
| |
| * Dient zum Warten auf einen oder alle Hintergrundprozesse.
| |
| * Wird keine Prozess- oder Jobnummer angegeben, so wird auf die Terminierung aller Hintergrundprozesse gewartet und der Rückgabewert ist 0.
| |
| * Mit Spezifizierung einer Nummer wird genau auf den betreffenden Prozess gewartet und dessen Rückgabestatus ist der Rückgabewert von »wait«.
| |
|
| |
| = Links =
| |
| == Dateien ==
| |
|
| |
| == Man-Pages ==
| |
|
| |
|
| == Intern == | | == Aufruf == |
| | <syntaxhighlight lang="bash" highlight="1" line> |
|
| |
|
| == Weblinks == | | </syntaxhighlight> |
| | === Optionen === |
| | === Parameter === |
| | === Umgebungsvariablen === |
| | === Exit-Status === |
| | == Anwendung == |
| | === Problembehebung === |
| | == Konfiguration == |
| | === Dateien === |
| | <noinclude> |
| | == Anhang == |
| | === Siehe auch === |
| | {{Special:PrefixIndex/{{BASEPAGENAME}}}} |
|
| |
|
| | ==== Dokumentation ==== |
| | ===== Man-Page ===== |
| | ===== Info-Pages ===== |
| | ==== Links ==== |
| | ===== Weblinks ===== |
|
| |
|
| [[Kategorie:Linux:Shell:Bash]] | | [[Kategorie:Bash/Builtin]] |
| | </noinclude> |