Bash
Interne Variablen

Einführung

Bash interne Variablen auf einen Blick

Variable	Einzelheiten
$* / $@	Funktions- / Skript-Positionsparameter (Argumente). Erweitern Sie wie folgt: $* und $@ sind die gleichen wie $1 $2 ... (Beachten Sie, dass es im Allgemeinen keinen Sinn macht, diese nicht in Anführungszeichen zu setzen). "$*" ist das Gleiche wie "$1 $2 ..." 1 "$@" ist das gleiche wie "$1" "$2" ... 1. Argumente werden durch das erste Zeichen von $ IFS getrennt, wobei es sich nicht um ein Leerzeichen handeln muss.
$#	Anzahl der Positionsparameter, die an das Skript oder die Funktion übergeben werden
$!	Prozess-ID des letzten (am genauesten für Pipelines) -Befehls im letzten Job, der in den Hintergrund gestellt wird (beachten Sie, dass er nicht unbedingt der Prozessgruppen-ID des Jobs entspricht, wenn die Jobsteuerung aktiviert ist)
$$	ID des Prozesses, der bash ausgeführt hat
$?	Beenden Sie den Status des letzten Befehls
$n	Positionsparameter mit n = 1, 2, 3, ..., 9
${n}	Positionsparameter (wie oben), aber n kann> 9 sein
$0	In Skripten der Pfad, mit dem das Skript aufgerufen wurde. mit bash -c 'printf "%s\n" "$0"' name args' : name (das erste Argument nach dem Inline-Skript), andernfalls die von bash erhaltene argv[0] .
$_	Letztes Feld des letzten Befehls
$IFS	Internes Feldtrennzeichen
$PATH	Umgebungsvariable PATH, mit der nach ausführbaren Dateien gesucht wird
$OLDPWD	Vorheriges Arbeitsverzeichnis
$PWD	Vorhandenes Arbeitsverzeichnis
$FUNCNAME	Array mit Funktionsnamen im Ausführungsaufruf-Stack
$BASH_SOURCE	Array mit FUNCNAME für Elemente im FUNCNAME Array. Kann verwendet werden, um den Skriptpfad abzurufen.
$BASH_ALIASES	Assoziatives Array, das alle aktuell definierten Aliase enthält
$BASH_REMATCH	Array von Übereinstimmungen aus dem letzten Regex-Spiel
$BASH_VERSION	Bash-Versionszeichenfolge
$BASH_VERSINFO	Ein Array von 6 Elementen mit Bash-Versionsinformationen
$BASH	Absoluter Pfad zur aktuell ausgeführten Bash-Shell selbst (heuristisch durch bash basierend auf argv[0] und dem Wert von $PATH ; in $PATH kann es falsch sein)
$BASH_SUBSHELL	Bash Subshell-Ebene
$UID	Real (nicht wirksam, wenn abweichend) Benutzer-ID des Prozesses, der bash
$PS1	Primäre Eingabeaufforderung; Siehe Verwenden der PS * -Variablen
$PS2	Sekundäre Eingabeaufforderung (wird für zusätzliche Eingabe verwendet)
$PS3	Tertiär-Eingabeaufforderung (in Auswahlschleife verwendet)
$PS4	Quaternäre Eingabeaufforderung (wird verwendet, um Informationen mit ausführlicher Ausgabe anzufügen)
$RANDOM	Eine Pseudozufallszahl zwischen 0 und 32767
$REPLY	Variable, die standardmäßig von read wird, wenn keine Variable angegeben ist. Wird auch von select , um den vom Benutzer angegebenen Wert zurückzugeben
$PIPESTATUS	Arrayvariable, die die Exitstatuswerte jedes Befehls in der zuletzt ausgeführten Vordergrundpipeline enthält.

Die Zuweisung der Variablen darf vor und nach keinen Platz haben. a=123 nicht a = 123 . Letzteres (ein Gleichheitszeichen, das von Leerzeichen umgeben ist) bedeutet, dass der Befehl a mit den Argumenten = und 123 , obwohl er auch im String-Vergleichsoperator zu sehen ist (was syntaktisch ein Argument für [ oder [[ oder was auch immer Sie sind) ist using).

$ BASHPID

Prozess-ID (PID) der aktuellen Instanz von Bash. Dies ist nicht dasselbe wie die $$ -Variable, liefert jedoch oft das gleiche Ergebnis. Dies ist neu in Bash 4 und funktioniert nicht in Bash 3.

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

$ BASH_ENV

Eine Umgebungsvariable, die auf die Bash-Startdatei verweist, die gelesen wird, wenn ein Skript aufgerufen wird.

$ BASH_VERSINFO

Ein Array mit den vollständigen Versionsinformationen, aufgeteilt in Elemente. $BASH_VERSION ist viel praktischer als $BASH_VERSION wenn Sie nur nach der Hauptversion suchen:

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

$ BASH_VERSION

Zeigt die Version von bash an, die ausgeführt wird. Dadurch können Sie entscheiden, ob Sie erweiterte Funktionen verwenden können:

~> $ echo $BASH_VERSION
4.1.2(1)-release

$ EDITOR

Der Standardeditor, der von Skripts oder Programmen verwendet wird, normalerweise vi oder emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

Um den Namen der aktuellen Funktion abzurufen, geben Sie Folgendes ein:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

Diese Anweisung gibt nichts zurück, wenn Sie sie außerhalb der Funktion eingeben:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

$ HOME

Das Heimatverzeichnis des Benutzers

~> $ echo $HOME
/home/user

$ HOSTNAME

Der Hostname, der dem System beim Start zugewiesen wurde.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Diese Variable identifiziert die Hardware. Sie kann nützlich sein, um zu bestimmen, welche Binärdateien ausgeführt werden sollen:

~> $ echo $HOSTTYPE
x86_64

$ GRUPPEN

Ein Array mit der Anzahl der Gruppen, in denen sich der Benutzer befindet:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members" 
done

$ IFS

Enthält die Zeichenfolge für das interne Feldtrennzeichen, die vom Bash zum Teilen von Zeichenfolgen beim Schleifen usw. verwendet wird. Die Standardeinstellung sind Leerzeichen: \n (Zeilenvorschub), \t (Tabulator) und Leerzeichen. Wenn Sie dies in etwas anderes ändern, können Sie Zeichenfolgen mit unterschiedlichen Zeichen aufteilen:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done 

Die Ausgabe des obigen ist:

a
b
c
d

Anmerkungen:

• Dies ist für das Phänomen verantwortlich, das als Wortaufspaltung bekannt ist .

$ LINENO

Gibt die Zeilennummer im aktuellen Skript aus. Meist nützlich beim Debuggen von Skripten.

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

$ MACHTYPE

Ähnlich wie oben bei $HOSTTYPE sind auch Informationen zum Betriebssystem sowie Hardware enthalten

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

$ OLDPWD

OLDPWD ( OLDP Rint W orking D irectory) enthält ein Verzeichnis vor dem letzten cd Befehl:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

$ OSTYPE

Gibt Informationen über die Art des Betriebssystems zurück, das auf der Maschine ausgeführt wird, z.

~> $ echo $OSTYPE
linux-gnu

$ PATH

Der Suchpfad zum Suchen von Binärdateien für Befehle. Häufige Beispiele sind /usr/bin und /usr/local/bin .

Wenn ein Benutzer oder Skript versucht, einen Befehl auszuführen, werden die Pfade in $PATH durchsucht, um eine übereinstimmende Datei mit Ausführungsberechtigung zu finden.

Die Verzeichnisse in $PATH sind durch ein Zeichen : getrennt.

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

Wenn Sie beispielsweise $PATH lss nach der Eingabeaufforderung lss , sucht die Shell nach /usr/kerberos/bin/lss /usr/local/bin/lss /bin/lss /usr/bin/lss in dieser Reihenfolge, bevor geschlossen wird, dass es keinen solchen Befehl gibt.

$ PPID

Die Prozess-ID (pid) des übergeordneten Skripts oder der Shell, dh der Prozess, als das aktuelle Skript oder die aktuelle Shell aufgerufen wurde.

~> $ echo $$
13016
~> $ echo $PPID
13015

$ PWD

PWD (P rint W orking D irectory) Das aktuelle Arbeitsverzeichnis Sie sind im Moment:

~> $ echo $PWD
/home/user
~> $ cd directory
directory> $ echo $PWD
/home/user/directory

$ SEKUNDEN

Die Anzahl der Sekunden, die ein Skript ausgeführt wurde. Dies kann ziemlich groß werden, wenn es in der Shell angezeigt wird:

~> $ echo $SECONDS
98834

$ SHELLOPTS

Eine lesbare Liste der Optionen bash wird beim Start zur Verfügung gestellt, um deren Verhalten zu steuern:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

$ SHLVL

Wenn der Bash-Befehl ausgeführt wird, wird eine neue Shell geöffnet. Die Umgebungsvariable $ SHLVL enthält die Anzahl der Shell-Ebenen, auf denen die aktuelle Shell ausgeführt wird.

Wenn Sie den folgenden Befehl ausführen, werden in einem neuen Terminalfenster unterschiedliche Ergebnisse basierend auf der verwendeten Linux-Distribution erzeugt.

echo $SHLVL

Bei Verwendung von Fedora 25 ist die Ausgabe "3". Dies zeigt an, dass beim Öffnen einer neuen Shell ein erster Bash-Befehl ausgeführt und eine Aufgabe ausgeführt wird. Der anfängliche Bash-Befehl führt einen untergeordneten Prozess (einen anderen Bash-Befehl) aus, der wiederum einen abschließenden Bash-Befehl ausführt, um die neue Shell zu öffnen. Wenn die neue Shell geöffnet wird, wird sie als untergeordneter Prozess von 2 anderen Shell-Prozessen ausgeführt, daher die Ausgabe von "3".

Im folgenden Beispiel (vorausgesetzt der Benutzer führt Fedora 25 aus), wird die Ausgabe von $ SHLVL in einer neuen Shell auf "3" gesetzt. Während der Ausführung jedes Bash-Befehls wird $ SHLVL um eins erhöht.

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

Man kann sehen, dass das Ausführen des 'bash'-Befehls (oder das Ausführen eines Bash-Skripts) eine neue Shell öffnet. Im Vergleich dazu führt die Beschaffung eines Skripts den Code in der aktuellen Shell aus.

test1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

test2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

Ausführen:

chmod +x test1.sh && chmod +x run.sh
./run.sh

Ausgabe:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

$ UID

Eine schreibgeschützte Variable, in der die ID-Nummer des Benutzers gespeichert ist:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 etc ...

Positionsparameter, die entweder von der Befehlszeile oder einer Funktion an das Skript übergeben werden:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

Die Ausgabe des obigen ist:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

Wenn die Anzahl der Positionsargumente größer als neun ist, müssen geschweifte Klammern verwendet werden.

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10 
echo ${10}

$ #

Um die Anzahl der Befehlszeilenargumente oder Positionsparameter abzurufen, geben Sie Folgendes ein:

#!/bin/bash
echo "$#"

Bei Ausführung mit drei Argumenten ergibt das obige Beispiel die Ausgabe:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

$ *

Gibt alle Positionsparameter in einer einzelnen Zeichenfolge zurück.

testscript.sh:

#!/bin/bash
echo "$*"

Führen Sie das Skript mit mehreren Argumenten aus:

./testscript.sh firstarg secondarg thirdarg 

Ausgabe:

firstarg secondarg thirdarg

$!

Die Prozess-ID (PID) des letzten im Hintergrund ausgeführten Jobs:

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

$ _

Gibt das letzte Feld des zuletzt ausgeführten Befehls aus, was nützlich ist, um etwas an einen anderen Befehl weiterzuleiten:

 ~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

---

Gibt den Skriptpfad an, wenn er vor anderen Befehlen verwendet wird:

test.sh:

#!/bin/bash
echo "$_"

Ausgabe:

~> $ ./test.sh # running test.sh
./test.sh

Hinweis: Dies ist keine narrensichere Methode, um den Skriptpfad abzurufen

$?

Der Beendigungsstatus der zuletzt ausgeführten Funktion oder des Befehls. Normalerweise bedeutet 0 OK, alles andere weist auf einen Fehler hin:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

$$

Die Prozess-ID (PID) des aktuellen Prozesses:

~> $ echo $$
13246

$ @

"$@" auf alle Befehlszeilenargumente als separate Wörter erweitert. Es unterscheidet sich von "$*" , das alle Argumente als ein einzelnes Wort erweitert.

"$@" ist besonders nützlich, wenn Sie Argumente durchlaufen und Argumente mit Leerzeichen behandeln.

Stellen Sie sich vor, wir befinden uns in einem Skript, das wir mit zwei Argumenten aufgerufen haben:

$ ./script.sh "␣1␣2␣" "␣3␣␣4␣"

---

Die Variablen $* oder $@ erweitern sich zu $1␣$2 , die wiederum zu 1␣2␣3␣4 also der folgenden Schleife:

for var in $*; do # same for var in $@; do
    echo \<"$var"\>
done

wird für beide drucken

<1>
<2>
<3>
<4>

---

Während "$*" zu "$1␣$2" erweitert wird, wird es zu "␣1␣2␣␣␣3␣␣4␣" und die Schleife:

for var in "$*"; do
    echo \<"$var"\>   
done

ruft echo einmal auf und druckt

<␣1␣2␣␣␣3␣␣4␣>

---

Und schließlich wird "$@" zu "$1" "$2" , was zu "␣1␣2␣" "␣3␣␣4␣" und damit zur Schleife führt

for var in "$@"; do
    echo \<"$var"\>
done

wird drucken

<␣1␣2␣>
<␣3␣␣4␣>

Dadurch bleiben sowohl der interne Abstand in den Argumenten als auch die Trennung der Argumente erhalten. Beachten Sie, dass die Konstruktion for var in "$@"; do ... ist so allgemein und idiomatisch, dass es die Standardeinstellung für eine for-Schleife ist und auf for var; do ... verkürzt werden kann for var; do ...

$ HISTSIZE

Die maximale Anzahl an gespeicherten Befehlen:

~> $ echo $HISTSIZE
1000

$ RANDOM

Bei jeder Referenzierung dieses Parameters wird eine zufällige Ganzzahl zwischen 0 und 32767 generiert. Wenn Sie dieser Variablen einen Wert zuweisen, wird der Zufallszahlengenerator ( Quelle ) erstellt.

~> $ echo $RANDOM 
27119
~> $ echo $RANDOM 
1349