105.1 Lektion 2

Zertifikat:

LPIC-1

Version:

5.0

Thema:

105 Shells und Shell-Skripte

Lernziel:

105.1 Die Shell-Umgebung anpassen und verwenden

Lektion:

2 von 3

Einführung

Stellen Sie sich eine Variable als ein Kästchen vor, in dem Sie vorübergehend eine Information ablegen. Wie bei den Initialisierungsskripten klassifiziert die Bash Variablen entweder als Shell-spezifisch/lokal (also solche, die nur innerhalb der Grenzen der Shell existieren, in der sie erstellt wurden) oder als Umgebung/global (solche, die an untergeordnete Shells und/oder Prozesse vererbt werden). In der vorangegangenen Lektion haben wir uns Shells und ihre Konfigurations- oder Initialisierungsskripte angesehen. Nun geht es darum, dass die Stärke dieser Startdateien darin liegt, dass sie uns erlauben, Variablen — sowie Aliasse und Funktionen — zu verwenden, über die wir die Shell-Umgebung unserer Wahl erstellen und anpassen.

Variablen: Zuweisung und Referenz

Wir können eine Variable als Namen definieren, der einen Wert enthält.

In der Bash nennt man die Zuordnung eines Werts zu einem Namen Variablenzuweisung — und so erstellen oder setzen wir Variablen. Der Vorgang, auf den im Namen enthaltenen Wert zuzugreifen, bezeichnet man als Variablenreferenzierung.

Die Syntax für die Zuweisung lautet:

<Variablenname>=<Variablenwert>

Zum Beispiel:

$ distro=zorinos

Die Variable distro ist gleich zorinos — es gibt also einen Teil des Speichers, der den Wert zorinos enthält, und distro ist der Zeiger darauf.

Beachten Sie, dass bei der Zuweisung einer Variablen kein Leerzeichen auf beiden Seiten des Gleichheitszeichens stehen darf:

$ distro =zorinos
-bash: distro: command not found
$ distro= zorinos
-bash: zorinos: command not found

Aufgrund unseres Fehlers hat die Bash distro und zorinos als Befehle interpretiert.

Um eine Variable zu referenzieren (d.h. ihren Wert zu überprüfen), verwenden wir den Befehl echo, gefolgt vom Variablennamen mit vorangestelltem $-Zeichen:

$ echo $distro
zorinos

Variablennamen

Bei der Wahl von Variablennamen sind einige Regeln zu berücksichtigen:

Der Name einer Variablen darf Buchstaben (a-z,A-Z), Zahlen (0-9) und Unterstriche (_) enthalten:

$ distro=zorinos
$ echo $distro
zorinos
$ DISTRO=zorinos
$ echo $DISTRO
zorinos
$ distro_1=zorinos
$ echo $distro_1
zorinos
$ _distro=zorinos
$ echo $_distro
zorinos

Der Name darf nicht mit einer Zahl beginnen:

$ 1distro=zorinos
-bash: 1distro=zorinos: command not found

Der Name darf keine Leerzeichen enthalten (auch nicht unter Verwendung von Anführungszeichen) — per Konvention werden stattdessen Unterstriche verwendet:

$ "my distro"=zorinos
-bash: my: command not found
$ my_distro=zorinos
$ echo $my_distro
zorinos

Variablenwerte

Bei der Referenz oder den Werten von Variablen ist es ebenfalls wichtig, einige Regeln zu beachten:

Variablen können beliebige alphanumerische Zeichen (a-z,A-Z,0-9) sowie die meisten anderen Zeichen (?,!,*,.,/ etc.) enthalten:

$ distro=zorin12.4?
$ echo $distro
zorin12.4?

Variablenwerte müssen in Anführungszeichen gesetzt werden, wenn sie Leerzeichen enthalten:

$ distro=zorin 12.4
-bash: 12.4: command not found
$ distro="zorin 12.4"
$ echo $distro
zorin 12.4
$ distro='zorin 12.4'
$ echo $distro
zorin 12.4

Variablenwerte müssen auch in Anführungszeichen eingeschlossen werden, wenn sie Zeichen wie die für die Umleitung reservierten (<, >) oder das Pipe-Symbol (|) enthalten. Darum bewirkt der folgende Befehl lediglich, dass eine leere Datei namens zorin angelegt wird:

$ distro=>zorin
$ echo $distro

$ ls zorin
zorin

Mit Anführungszeichen funktioniert es:

$ distro=">zorin"
$ echo $distro
>zorin

Einfache und doppelte Anführungszeichen sind jedoch nicht immer austauschbar. Abhängig davon, was wir mit einer Variable tun (zuweisen oder referenzieren), führt die Verwendung der einen oder der anderen zu unterschiedlichen Ergebnissen. Bei der Variablenzuweisung bewirken einfache Anführungszeichen, dass alle Zeichen des Variablenwerts “wörtlich” genommen werden — während doppelte Anführungszeichen eine Variablenersetzung ermöglichen:

$ lizard=uromastyx
$ animal='My $lizard'
$ echo $animal
My $lizard
$ animal="My $lizard"
$ echo $animal
My uromastyx

Andererseits ist es beim Verweis auf eine Variable, deren Wert (anfängliche oder zusätzliche) Leerzeichen enthält — manchmal in Verbindung mit Sternchen — zwingend erforderlich, nach dem Befehl echo doppelte Anführungszeichen zu setzen, um Feldaufteilung (field splitting) und Pfadnamenerweiterung (pathname expansion) zu vermeiden:

$ lizard="   genus   |   uromastyx"
$ echo $lizard
genus | uromastyx
$ echo "$lizard"
   genus   |   uromastyx

Enthält die Referenz der Variablen ein abschließendes Ausrufezeichen, muss dies das letzte Zeichen in der Zeichenkette sein (da Bash andernfalls von einem Verweis auf ein Ereignis in history ausgeht):

$ distro=zorin.?/!os
-bash: !os: event not found
$ distro=zorin.?/!
$ echo $distro
zorin.?/!

Alle Backslashes müssen mit einem weiteren Backslash escapet werden. Ist ein Backslash das letzte Zeichen in der Zeichenkette und wird er nicht escapet, interpretiert Bash das als Zeilenumbruch und erwartet eine neue Zeile:

$ distro=zorinos\
>
$ distro=zorinos\\
$ echo $distro
zorinos\

In den folgenden Abschnitten werden wir die wichtigsten Unterschiede zwischen lokalen Variablen und Umgebungsvariablen zusammenfassen.

Lokale oder Shellvariablen

Lokale oder Shellvariablen existieren nur in der Shell, in der sie erstellt wurden. Üblicherweise werden lokale Variablen in Kleinbuchstaben geschrieben.

Für ein paar Tests legen wir eine lokale Variable an. Dafür wählen wir einen geeigneten Variablennamen und weisen ihm einen Wert zu, zum Beispiel:

$ reptile=tortoise

Nun nutzen wir den Befehl echo, um unsere Variable zu referenzieren und zu überprüfen, ob alles erwartungsgemäß funktioniert hat:

$ echo $reptile
tortoise

In bestimmten Szenarien — z.B. beim Schreiben von Skripten — kann die Unveränderbarkeit eine interessante Eigenschaft von Variablen sein. Wenn wir wollen, dass unsere Variable unveränderbar ist, erstellen wir sie entweder mittels readonly:

$ readonly reptile=tortoise

Oder wir machen sie schreibgeschützt, nachdem sie erstellt wurde:

$ reptile=tortoise
$ readonly reptile

Wenn wir nun versuchen, den Wert von reptile zu ändern, weigert sich Bash:

$ reptile=lizard
-bash: distro: readonly variable

Note	Um alle schreibgeschützten Variablen in unserer aktuellen Sitzung aufzulisten, geben Sie `readonly` oder `readonly -p` in das Terminal ein.

Ein nützlicher Befehl im Umgang mit lokalen Variablen ist set.

set gibt alle aktuell zugewiesenen Shellvariablen und -funktionen aus. Da das sehr viele Zeilen sein können (probieren Sie es selbst aus!), empfiehlt es sich, set in Kombination mit einem Pager wie less zu verwenden:

$ set | less
BASH=/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()
BASH_CMDS=()
BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
BASH_LINENO=()
BASH_SOURCE=()
BASH_VERSINFO=([0]="4" [1]="4" [2]="12" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu")
BASH_VERSION='4.4.12(1)-release'
(...)

Ist unsere Variable reptile vorhanden?

$ set | grep reptile
reptile=tortoise

Ja, da ist sie!

Allerdings wird reptile — da es sich um eine lokale Variable handelt — nicht an alle Kindprozesse vererbt, die von der aktuellen Shell gestartet werden:

$ bash
$ set | grep reptile
$

Und natürlich können wir ihren Wert auch nicht augeben lassen:

$ echo $reptile
$

Note	Durch Eingabe des Befehls `bash` in das Terminal öffnen wir eine neue (untergeordnete) Shell.

Um eine Variable (lokal oder global) zurückzusetzen, verwenden wir den Befehl unset:

$ echo $reptile
tortoise
$ unset reptile
$ echo $reptile
$

Note	Auf `unset` muss der Name der Variablen folgen (ohne vorangestelltes `$`-Symbol).

Globale oder Umgebungsvariablen

Globale oder Umgebungsvariablen existieren sowohl für die aktuelle Shell als auch für alle nachfolgenden Prozesse, die von ihr erzeugt wurden. Per Konvention werden Umgebungsvariablen in Großbuchstaben geschrieben:

$ echo $SHELL
/bin/bash

Wir können den Wert dieser Variablen rekursiv an andere Variablen übergeben, die diesen dann übernehmen:

$ my_shell=$SHELL
$ echo $my_shell
/bin/bash
$ your_shell=$my_shell
$ echo $your_shell
/bin/bash
$ our_shell=$your_shell
$ echo $our_shell
/bin/bash

Um eine lokale Shellvariable zu einer Umgebungsvariablen zu machen, nutzen Sie den Befehl export:

$ export reptile

Mit export reptile haben wir unsere lokale Variable in eine Umgebungsvariable verwandelt, so dass Kind-Shells diese erkennen und verwenden können:

$ bash
$ echo $reptile
tortoise

Ebenso dient export dazu, eine Variable in einem Schritt zu setzen und zu exportieren:

$ export amphibian=frog

Jetzt können wir eine neue Instanz der Bash öffnen und die neue Variable erfolgreich referenzieren:

$ bash
$ echo $amphibian
frog

Note	Mit `export -n <VARIABLENNNAME>` wandeln Sie die Variable wieder in eine lokale Shellvariable um.

Der Befehl export liefert uns auch eine Liste aller vorhandenen Umgebungsvariablen, wenn er allein (oder mit der Option -p) aufgerufen wird:

$ export
declare -x HOME="/home/user2"
declare -x LANG="en_GB.UTF-8"
declare -x LOGNAME="user2"
(...)
declare -x PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
declare -x PWD="/home/user2"
declare -x SHELL="/bin/bash"
declare -x SHLVL="1"
declare -x SSH_CLIENT="192.168.1.10 49330 22"
declare -x SSH_CONNECTION="192.168.1.10 49330 192.168.1.7 22"
declare -x SSH_TTY="/dev/pts/0"
declare -x TERM="xterm-256color"
declare -x USER="user2"
declare -x XDG_RUNTIME_DIR="/run/user/1001"
declare -x XDG_SESSION_ID="8"
declare -x reptile="tortoise"

Note	Der Befehl `declare -x` ist äquivalent zu `export`.

Zwei weitere Befehle, mit denen Sie eine Liste aller Umgebungsvariablen ausgeben, sind env und printenv:

$ env
SSH_CONNECTION=192.168.1.10 48678 192.168.1.7 22
LANG=en_GB.UTF-8
XDG_SESSION_ID=3
USER=user2
PWD=/home/user2
HOME=/home/user2
SSH_CLIENT=192.168.1.10 48678 22
SSH_TTY=/dev/pts/0
MAIL=/var/mail/user2
TERM=xterm-256color
SHELL=/bin/bash
SHLVL=1
LOGNAME=user2
XDG_RUNTIME_DIR=/run/user/1001
PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
_=/usr/bin/env

Abgesehen davon, dass es ein Synonym für env ist, können wir printenv in ähnlicher Weise verwenden wie den Befehl echo, um den Wert einer Variablen zu überprüfen:

$ echo $PWD
/home/user2
$ printenv PWD
/home/user2

Beachten Sie jedoch, dass bei printenv dem Variablennamen kein $ vorangestellt wird.

Note	`PWD` speichert den Pfad des aktuellen Arbeitsverzeichnisses. Wir werden diese und andere gängige Umgebungsvariablen später kennenlernen.

Ausführen eines Programms in einer geänderten Umgebung

Mit env ändern Sie die Shellumgebung während der Ausführung eines Programms.

Um eine neue Bashsitzung mit einer möglichst leeren Umgebung zu starten — die meisten Variablen (sowie Funktionen und Aliasse) werden gelöscht — verwenden wir env mit der Option -i:

$ env -i bash

Nun sind die meisten Umgebungsvariablen verschwunden:

$ echo $USER
$

Es bleiben nur wenige übrig:

$ env
LS_COLORS=
PWD=/home/user2
SHLVL=1
_=/usr/bin/printenv

Wir können env auch dazu verwenden, eine bestimmte Variable für ein bestimmtes Programm zu setzen.

In der vorangegangenen Lektion, in der es um nicht-interaktive Shells ohne Login ging, haben wir gesehen, wie Skripte keine Standardstartdateien lesen, sondern stattdessen nach dem Wert der Variable BASH_ENV suchen und diese als ihre Startdatei verwenden, sofern sie existiert.

Lassen Sie uns diesen Vorgang demonstrieren:

Wir erstellen unsere eigene Startupdatei namens .startup_script mit folgendem Inhalt:
```
CROCODILIAN=caiman
```
Wir schreiben ein Bashskript namens test_env.sh mit folgendem Inhalt:
```
#!/bin/bash

echo $CROCODILIAN
```
Wir setzen das Ausführungsbit für unser Skript test_env.sh:
```
$ chmod +x test_env.sh
```
Schließlich verwenden wir env, um BASH_ENV auf .startup_script für test_env.sh zu setzen:
```
$ env BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```
Der Befehl env ist implizit, auch wenn wir ihn nicht angeben:
```
$ BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```

Note

Wenn Sie die Zeile #!/bin/bash oder den Befehl chmod +x nicht verstehen, keine Panik! Wir werden alles Notwendige über Shellskripte in künftigen Lektionen besprechen. Für den Moment merken Sie sich einfach, dass wir ./some_script verwenden, um ein Skript aus seinem eigenen Verzeichnis heraus auszuführen.

Gemeinsame Umgebungsvariablen

Nun ist es an der Zeit, einige der wichtigsten Umgebungsvariablen zu betrachten, die in den Konfigurationsdateien der Bash gesetzt werden.

DISPLAY

Bezogen auf den X-Server, setzt sich der Wert dieser Variablen normalerweise aus drei Elementen zusammen:

Der Hostname (das Fehlen bedeutet localhost), auf dem der X-Server läuft.
Ein Doppelpunkt als Begrenzungszeichen.
Eine Zahl (normalerweise 0), die auf den Bildschirm des Computers verweist.
```
$ printenv DISPLAY
:0
```
Ein leerer Wert für diese Variable steht für einen Server ohne X Window System. Eine zusätzliche Zahl — wie in my.xserver:0:1 — würde sich auf die Bildschirmnummer beziehen, wenn mehr als einer existiert.

HISTCONTROL

Diese Variable steuert, welche Befehle in HISTFILE gespeichert werden (siehe unten). Es gibt drei mögliche Werte:

ignorespace

Befehle, die mit einem Leerzeichen beginnen, werden nicht gespeichert.

ignoredups

Ein Befehl, der mit dem vorherigen identisch ist, wird nicht gespeichert.

ignoreboth

Befehle, die in eine der beiden vorherigen Kategorien fallen, werden nicht gespeichert.

$ echo $HISTCONTROL
ignoreboth

HISTSIZE

Dies bestimmt die Anzahl der Befehle, die während der Dauer der Shellsitzung im Speicher vorgehalten wird.

$ echo $HISTSIZE
1000

HISTFILESIZE

Dies bestimmt die Anzahl der Befehle, die sowohl zu Beginn als auch am Ende der Sitzung in HISTFILE gespeichert werden:

$ echo $HISTFILESIZE
2000

HISTFILE

Der Name der Datei, die alle Befehle speichert, wie sie eingegeben werden. Standardmäßig befindet sich diese Datei unter ~/.bash_history:

$ echo $HISTFILE
/home/user2/.bash_history

Note	Um den Inhalt von `HISTFILE` zu sehen, geben wir einfach `history` ein. Alternativ geben wir die Anzahl der Befehle an, die wir sehen wollen, indem wir ein Argument (die Nummer der letzten Befehle) an `history` übergeben, wie in `history 3`.

HOME

Diese Variable speichert den absoluten Pfad des Homeverzeichnisses des aktuellen Benutzers und wird gesetzt, wenn sich der Benutzer anmeldet.

Dieses Stück Code — aus ~/.profile — ist selbsterklärend (es sourcet "$HOME/.bashrc", wenn es existiert):

    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi

Note	Wenn Sie die `if`-Anweisung nicht ganz verstehen, machen Sie sich keine Sorgen: Schauen Sie einfach in den Lektionen über Shellscripting nach.

Denken Sie daran, dass ~ äquivalent zu $HOME ist:

$ echo ~; echo $HOME
/home/carol
/home/carol

Note	Befehle können mit einem Semikolon (`;`) konkateniert werden.

Wir können dies auch mit einer if-Anweisung belegen:

$ if [ ~ == "$HOME" ]; then echo "true"; else echo "false"; fi
true

Note	Zur Erinnerung: Das Gleichheitszeichen `=` wird für die Variablenzuweisung verwendet, `==` zum Testen auf Gleichheit.

HOSTNAME

Diese Variable speichert den TCP/IP-Namen des Host-Computers:

$ echo $HOSTNAME
debian

HOSTTYPE

Speichert die Prozessorarchitektur des Host-Computers:

$ echo $HOSTTYPE
x86_64

LANG

Diese Variable speichert das Gebietsschema des Systems:

$ echo $LANG
en_UK.UTF-8

LD_LIBRARY_PATH

Diese Variable besteht aus einer durch Doppelpunkte getrennten Reihe von Verzeichnissen, in denen Shared Librabries von Programmen gemeinsam genutzt werden:

$ echo $LD_LIBRARY_PATH
/usr/local/lib

MAIL

Diese Variable speichert die Datei, in der die Bash nach E-Mails sucht:

$ echo $MAIL
/var/mail/carol

Ein anderer üblicher Wert für diese Variable ist /var/spool/mail/$USER.

MAILCHECK

Diese Variable speichert einen numerischen Wert, der in Sekunden das Intervall angibt, in dem die Bash nach neuen Mails sucht:

$ echo $MAILCHECK
60

PATH

Diese Umgebungsvariable speichert die Liste der Verzeichnisse, in denen die Bash nach ausführbaren Dateien sucht, wenn sie aufgefordert wird, ein Programm auszuführen. In unserem Beispielsystem wird diese Variable über die systemweite Datei /etc/profile gesetzt:

if [ "`id -u`" -eq 0 ]; then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
export PATH

Die if-Anweisung prüft die Identität des Benutzers und — je nach Ergebnis (root oder nicht) — erhalten wir den einen oder den anderen PATH. Schließlich wird der gewählte PATH mit export propagiert.

Beachten Sie zwei Dinge in Bezug auf den Wert von PATH:

Verzeichnisnamen werden mit absoluten Pfaden geschrieben.

Der Doppelpunkt dient als Trennzeichen.

Um das Verzeichnis /usr/local/sbin für normale Benutzer in den PATH aufzunehmen, ändern wir die Zeile wie folgt:

(...)
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin"
fi
export PATH

Wir sehen, wie sich der Wert der Variable ändert, wenn wir uns als normaler Benutzer anmelden:

# su - carol
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin

Note

Wir hätten auch /usr/local/sbin zum PATH des Benutzers auf der Kommandozeile hinzufügen können, indem wir entweder PATH=/usr/local/sbin:$PATH oder PATH=$PATH:/usr/local/sbin eingeben. Der erste Befehl macht /usr/local/sbin zum ersten Verzeichnis, das nach ausführbaren Dateien durchsucht wird — der zweite macht es zum letzten.

PS1

Diese Variable speichert den Wert der Basheingabeaufforderung (Prompt). Im folgenden Codestück (ebenfalls aus /etc/profile) prüft die if-Anweisung auf die Identität des Benutzers und gibt eine entsprechende Eingabeaufforderung (# für root oder $ für normale Benutzer):

if [ "`id -u`" -eq 0 ]; then
  PS1='# '
else
  PS1='$ '
fi

Note	Die `id` von `root` lautet `0`. Werden Sie `root` und testen Sie es selbst mit `id -u`.

Andere Promptvariablen umfassen:

PS2: Meist auf > gesetzt und als Fortsetzungsprompt für mehrzeilige Befehle verwendet.
PS3: Meist als Eingabeaufforderung für den Befehl select verwendet.
PS4: Meist auf + gesetzt und zum Debuggen verwendet.

SHELL

Diese Variable speichert den absoluten Pfad der aktuellen Shell:

$ echo $SHELL
/bin/bash

USER

Hier wird der Name des aktuellen Benutzers gespeichert:

$ echo $USER
carol

Geführte Übungen

Betrachten Sie die Variablenzuweisung in der Spalte “Befehl(e)” und geben Sie an, ob die resultierende Variable “Lokal” oder “Global” ist:

Befehl(e) Lokal Global

debian=mother

ubuntu=deb-based

mint=ubuntu-based; export mint

export suse=rpm-based

zorin=ubuntu-based
Betrachten Sie den “Befehl” sowie dessen “Ausgabe” und nennen Sie deren Bedeutung:

Befehl Ausgabe Bedeutung

echo $HISTCONTROL

ignoreboth

echo ~

/home/carol

echo $DISPLAY

reptilium:0:2

echo $MAILCHECK

60

echo $HISTFILE

/home/carol/.bash_history

In der Spalte “Falscher Befehl” sind Variablen falsch gesetzt. Geben Sie die fehlenden Informationen unter “Richtiger Befehl” und “Variablenreferenz” an, um die “Erwartete Ausgabe” zu erhalten:

Falscher Befehl Richtiger Befehl Variablenreferenz Erwartete Ausgabe

lizard =chameleon

chameleon

cool lizard=chameleon

chameleon

lizard=cha|me|leon

cha|me|leon

lizard=/** chameleon **/

/** chamelon **/

win_path=C:\path\to\dir\

C:\path\to\dir\

Betrachten Sie den “Zweck” und schreiben Sie den entsprechenden Befehl:

Zweck Befehl

Setzen Sie die Sprache der aktuellen Shell auf Spanisch UTF-8 (es_ES.UTF-8).

Ausgabe des Namens des aktuellen Arbeitsverzeichnisses.

Verweist auf die Umgebungsvariable, die die Informationen über ssh-Verbindungen speichert.

Setzen Sie PATH so, dass /home/carol/scripts als letztes Verzeichnis für die Suche nach ausführbaren Dateien einbezogen wird.

Setzen Sie den Wert von my_path auf PATH.

Setzen Sie den Wert von my_path auf den Wert von PATH.

Erzeugen Sie eine lokale Variable namens mammal und weisen Sie ihr den Wert gnu zu:
Erstellen Sie mit Hilfe der Variablensubstitution eine weitere lokale Variable namens var_sub mit dem entsprechenden Wert, so dass Sie, wenn Sie über echo $var_sub referenzieren, folgendes erhalten: The value of mammal is gnu:
Machen Sie mammal zu einer Umgebungsvariablen:
Suchen Sie danach mit set und grep:
Suchen Sie danach mit env und grep:
Erstellen Sie in zwei aufeinanderfolgenden Befehlen eine Umgebungsvariable namens BIRD, deren Wert penguin ist:
Erstellen Sie in einem einzelnen Befehl eine Umgebungsvariable namens NEW_BIRD, deren Wert yellow-eyed penguin ist:
Erstellen Sie als user2 ein Verzeichnis namens bin in Ihrem Homeverzeichnis:
Geben Sie den Befehl ein, um das Verzeichnis ~/bin zu Ihrem PATH hinzuzufügen, damit er das erste Verzeichnis ist, in dem bash nach ausführbaren Dateien sucht:
Welches Stück Code — in Form einer if-Anweisung — fügen Sie in ~/.profile ein, um sicherzustellen, dass der Wert von PATH über Neustarts hinweg unverändert bleibt?

Offene Übungen

let: mehr als arithmetische Ausdrucksauswertung:
- Suchen Sie in einer Manpage oder im Web nach let und seine Auswirkungen beim Setzen von Variablen und erstellen Sie eine neue lokale Variable namens my_val, deren Wert 10 ist — als Ergebnis der Addition von 5 und 5:
- Erzeugen Sie nun eine weitere Variable namens your_val, deren Wert 5 ist — als Ergebnis der Division des Wertes von my_val durch 2:
Das Ergebnis eines Befehls in einer Variablen? Das ist möglich und nennt sich Befehlssubstitution. Recherchieren Sie das Verfahren und betrachten Sie die folgende Funktion namens music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
Das Ergebnis des Befehls ls -l1t ~/Music | head -n 6 wird zum Wert der Variablen latest_music. Dann wird die Variable latest_music im Befehl echo referenziert (der die Gesamtzahl der vom Verzeichnis Music belegten Bytes und die letzten fünf dort gespeicherten Musikdateien ausgibt — eine pro Zeile).

Welcher der folgenden Ausdrücke ist ein gültiges Synonym für
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
Option A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```
Option B:
```
latest_music="(ls -l1t ~/Music| head -n 6)"
```
Option C:
```
latest_music=((ls -l1t ~/Music| head -n 6))
```

Zusammenfassung

In dieser Lektion haben wir gelernt:

Variablen sind ein sehr wichtiger Teil der Shellumgebung, da sie sowohl von der Shell selbst als auch von anderen Programmen verwendet werden.
Wie man Variablen zuweist und referenziert.
Die Unterschiede zwischen lokalen und globalen (oder Umgebungs-)Variablen.
Wie man Variablen readonly setzt.
Wie man eine lokale Variable mit dem Befehl export in eine Umgebungsvariable umwandelt.
Wie man alle Umgebungsvariablen auflistet.
Wie man ein Programm in einer modifizierten Umgebung ausführt.
Wie man Variablen mit Hilfe von Startup-Skripten persistent macht.
Einige gängige Umgebungsvariablen: DISPLAY, HISTCONTROL, HISTSIZE, HISTFILESIZE, HISTFILE, HOME, HOSTNAME, HOSTTYPE, LANG, LD_LIBRARY_PATH, MAIL, MAILCHECK, PATH, PS1 (und andere Prompt-Variablen), SHELL und USER.
Die Bedeutung der Tilde (~).
Die Grundlagen der if-Anweisungen.

In dieser Lektion verwendete Befehle:

echo: Referenziert eine Variable.
ls: Listet Verzeichnisinhalte auf.
readonly: Schützt Variablen vor Schreibzugriffen. Listet alle schreibgeschützten Variablen in der aktuellen Sitzung auf.
set: Listet alle Variablen und Funktionen in der aktuellen Sitzung auf.
grep: Liefert Zeilen, die einem Muster entsprechen.
bash: Startet eine neue Shell.
unset: Hebt eine gesetzte Variable auf.
export: Verwandelt eine lokale Variable in eine Umgebungsvariable. Listet Umgebungsvariablen auf.
env: Listet Umgebungsvariablen auf. Führt ein Programm in einer geänderten Umgebung aus.
printenv: Listet Umgebungsvariablen auf. Referenziert eine Variable.
chmod: Ändert die Modus-Bits einer Datei und macht sie z.B. ausführbar.
history: Listet vorherige Befehle auf.
su: Ändert die Benutzer-ID oder macht zum Superuser.
id: Gibt die Benutzer-ID aus.

Lösungen zu den geführten Übungen

Betrachten Sie die Variablenzuweisung in der Spalte “Befehl(e)” und geben Sie an, ob die resultierende Variable “Lokal” oder “Global” ist:

Befehl(e) Lokal Global

debian=mother

Ja

Nein

ubuntu=deb-based

Ja

Nein

mint=ubuntu-based; export mint

Nein

Ja

export suse=rpm-based

Nein

Ja

zorin=ubuntu-based

Ja

Nein

Betrachten Sie den “Befehl” sowie dessen “Ausgabe” und nennen Sie deren Bedeutung:

Befehl Ausgabe Bedeutung

echo $HISTCONTROL

ignoreboth

Sowohl doppelte Befehle als auch solche, die mit einem Leerzeichen beginnen, werden nicht in history gespeichert.

echo ~

/home/carol

Das HOME von carol ist /home/carol.

echo $DISPLAY

reptilium:0:2

Das System reptilium hat einen X-Server laufen, und wir verwenden den zweiten Bildschirm der Anzeige.

echo $MAILCHECK

60

Mail wird jede Minute geprüft.

echo $HISTFILE

/home/carol/.bash_history

history wird in /home/carol/.bash_history gespeichert.

Falscher Befehl Richtiger Befehl Variablenreferenz Erwartete Ausgabe

lizard =chameleon

lizard=chameleon

echo $lizard

chameleon

cool lizard=chameleon

cool_lizard=chameleon (for example)

echo $cool_lizard

chameleon

lizard=cha|me|leon

lizard="cha|me|leon" or lizard='cha|me|leon'

echo $lizard

cha|me|leon

lizard=/** chameleon **/

lizard="/** chameleon **/" or lizard='/** chameleon **/'

echo "$lizard"

/** chamelon **/

win_path=C:\path\to\dir\

win_path=C:\\path\\to\\dir\\

echo $win_path

C:\path\to\dir\

Betrachten Sie den “Zweck” und schreiben Sie den entsprechenden Befehl:

Zweck Befehl

Setzen Sie die Sprache der aktuellen Shell auf Spanisch UTF-8 (es_ES.UTF-8).

LANG=es_ES.UTF-8

Ausgabe des Namens des aktuellen Arbeitsverzeichnisses.

echo $PWD or pwd

Verweist auf die Umgebungsvariable, die die Informationen über ssh-Verbindungen speichert.

echo $SSH_CONNECTION

Setzen Sie PATH so, dass /home/carol/scripts als letztes Verzeichnis für die Suche nach ausführbaren Dateien einbezogen wird.

PATH=$PATH:/home/carol/scripts

Setzen Sie den Wert von my_path auf PATH.

my_path=PATH

Setzen Sie den Wert von my_path auf den Wert von PATH.

my_path=$PATH

Erzeugen Sie eine lokale Variable namens mammal und weisen Sie ihr den Wert gnu zu:
```
mammal=gnu
```
Erstellen Sie mit Hilfe der Variablensubstitution eine weitere lokale Variable namens var_sub mit dem entsprechenden Wert, so dass Sie, wenn Sie über echo $var_sub referenzieren, folgendes erhalten: The value of mammal is gnu:
```
var_sub="The value of mammal is $mammal"
```
Machen Sie mammal zu einer Umgebungsvariablen:
```
export mammal
```
Suchen Sie danach mit set und grep:
```
set | grep mammal
```
Suchen Sie danach mit env und grep:
```
env | grep mammal
```
Erstellen Sie in zwei aufeinanderfolgenden Befehlen eine Umgebungsvariable namens BIRD, deren Wert penguin ist:
```
BIRD=penguin; export BIRD
```
Erstellen Sie in einem einzigen Befehl eine Umgebungsvariable namens NEW_BIRD, deren Wert yellow-eyed penguin ist:
```
export NEW_BIRD="yellow-eyed penguin"
```
or
```
export NEW_BIRD='yellow-eyed penguin'
```
Erstellen Sie als user2 ein Verzeichnis namens bin in Ihrem Homeverzeichnis:
```
mkdir ~/bin
```
oder
```
mkdir /home/user2/bin
```
oder
```
mkdir $HOME/bin
```
Geben Sie den Befehl ein, um das Verzeichnis ~/bin zu Ihrem PATH hinzuzufügen, damit er das erste Verzeichnis ist, in dem bash nach ausführbaren Dateien sucht:
```
PATH="$HOME/bin:$PATH"
```
PATH=~/bin:$PATH oder PATH=/home/user2/bin:$PATH sind ebenfalls korrekt.
Welches Stück Code — in Form einer if-Anweisung — fügen Sie in ~/.profile ein, um sicherzustellen, dass der Wert von PATH über Neustarts hinweg unverändert bleibt?
```
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi
```

Lösungen zu den offenen Übungen

let: mehr als arithmetische Ausdrucksauswertung:
- Suchen Sie in einer Manpage oder im Web nach let und seine Auswirkungen beim Setzen von Variablen und erstellen Sie eine neue lokale Variable namens my_val, deren Wert 10 ist — als Ergebnis der Addition von 5 und 5:
  let "my_val = 5 + 5"
  oder
  let 'my_val = 5 + 5'
- Erzeugen Sie nun eine weitere Variable namens your_val, deren Wert 5 ist — als Ergebnis der Division des Wertes von my_val durch 2:
  let "your_val = $my_val / 2"
  oder
  let 'your_val = $my_val / 2'
Das Ergebnis eines Befehls in einer Variablen? Natürlich ist das möglich; man nennt es Befehlssubstitution. Recherchieren und studieren Sie die folgende Funktion namens music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
Das Ergebnis des Befehls ls -l1t ~/Music | head -n 6 wird zum Wert der Variablen latest_music. Dann wird die Variable latest_music im Befehl echo referenziert (der die Gesamtzahl der vom Ordner Music belegten Bytes und die letzten fünf im Ordner Music gespeicherten Musikdateien ausgibt — eine pro Zeile).

Welcher der folgenden Begriffe ist ein gültiges Synonym für
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
Es ist Option A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```