Linux Professional Institute Learning Logo.
Weiter zum Inhalt
  • Home
    • Alle Ressourcen
    • LPI Lernmaterialien
    • Mitmachen
    • Publishing Partner
    • Publishing Partner werden
    • Über uns
    • FAQ
    • Mitwirkende
    • Roadmap
    • Kontakt
  • LPI.org
105.1 Lektion 2
Thema 105: Shells und Shell-Skripte
105.1 Die Shell-Umgebung anpassen und verwenden
  • 105.1 Lektion 1
  • 105.1 Lektion 2
  • 105.1 Lektion 3
105.2 Einfache Skripte anpassen oder schreiben
  • 105.2 Lektion 1
  • 105.2 Lektion 2
Thema 106: Benutzerschnittstellen und Desktops
106.1 X11 installieren und konfigurieren
  • 106.1 Lektion 1
106.2 Grafische Desktops
  • 106.2 Lektion 1
106.3 Barrierefreiheit
  • 106.3 Lektion 1
Thema 107: Administrative Aufgaben
107.1 Benutzer- und Gruppenkonten und dazugehörige Systemdateien verwalten
  • 107.1 Lektion 1
  • 107.1 Lektion 2
107.2 Systemadministrationsaufgaben durch Einplanen von Jobs automatisieren
  • 107.2 Lektion 1
  • 107.2 Lektion 2
107.3 Lokalisierung und Internationalisierung
  • 107.3 Lektion 1
Thema 108: Grundlegende Systemdienste
108.1 Die Systemzeit verwalten
  • 108.1 Lektion 1
  • 108.1 Lektion 2
108.2 Systemprotokollierung
  • 108.2 Lektion 1
  • 108.2 Lektion 2
108.3 Grundlagen von Mail Transfer Agents (MTA)
  • 108.3 Lektion 1
108.4 Drucker und Druckvorgänge verwalten
  • 108.4 Lektion 1
Thema 109: Netzwerkgrundlagen
109.1 Grundlagen von Internetprotokollen
  • 109.1 Lektion 1
  • 109.1 Lektion 2
109.2 Persistente Netzwerkkonfiguration
  • 109.2 Lektion 1
  • 109.2 Lektion 2
109.3 Grundlegende Netzwerkfehlerbehebung
  • 109.3 Lektion 1
  • 109.3 Lektion 2
109.4 Clientseitiges DNS konfigurieren
  • 109.4 Lektion 1
Thema 110: Sicherheit
110.1 Administrationsaufgaben für Sicherheit durchführen
  • 110.1 Lektion 1
110.2 Einen Rechner absichern
  • 110.2 Lektion 1
110.3 Daten durch Verschlüsselung schützen
  • 110.3 Lektion 1
  • 110.3 Lektion 2
How to get certified
  1. Thema 105: Shells und Shell-Skripte
  2. 105.1 Die Shell-Umgebung anpassen und verwenden
  3. 105.1 Lektion 2

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:

  1. Wir erstellen unsere eigene Startupdatei namens .startup_script mit folgendem Inhalt:

    CROCODILIAN=caiman
  2. Wir schreiben ein Bashskript namens test_env.sh mit folgendem Inhalt:

    #!/bin/bash
    
    echo $CROCODILIAN
  3. Wir setzen das Ausführungsbit für unser Skript test_env.sh:

    $ chmod +x test_env.sh
  4. 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

  1. 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

  2. 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

  3. 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\

  4. 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.

  5. Erzeugen Sie eine lokale Variable namens mammal und weisen Sie ihr den Wert gnu zu:

  6. 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:

  7. Machen Sie mammal zu einer Umgebungsvariablen:

  8. Suchen Sie danach mit set und grep:

  9. Suchen Sie danach mit env und grep:

  10. Erstellen Sie in zwei aufeinanderfolgenden Befehlen eine Umgebungsvariable namens BIRD, deren Wert penguin ist:

  11. Erstellen Sie in einem einzelnen Befehl eine Umgebungsvariable namens NEW_BIRD, deren Wert yellow-eyed penguin ist:

  12. Erstellen Sie als user2 ein Verzeichnis namens bin in Ihrem Homeverzeichnis:

  13. 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:

  14. 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

  1. 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:

  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

  1. 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

  2. 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.

  3. 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

    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\

  4. 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

  5. Erzeugen Sie eine lokale Variable namens mammal und weisen Sie ihr den Wert gnu zu:

    mammal=gnu
  6. 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"
  7. Machen Sie mammal zu einer Umgebungsvariablen:

    export mammal
  8. Suchen Sie danach mit set und grep:

    set | grep mammal
  9. Suchen Sie danach mit env und grep:

    env | grep mammal
  10. Erstellen Sie in zwei aufeinanderfolgenden Befehlen eine Umgebungsvariable namens BIRD, deren Wert penguin ist:

    BIRD=penguin; export BIRD
  11. 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'
  12. Erstellen Sie als user2 ein Verzeichnis namens bin in Ihrem Homeverzeichnis:

    mkdir ~/bin

    oder

    mkdir /home/user2/bin

    oder

    mkdir $HOME/bin
  13. 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.

  14. 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

  1. 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'
  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)

Linux Professional Insitute Inc. Alle Rechte vorbehalten. Besuchen Sie die LPI Learning Website: https://learning.lpi.org
Dieses Werk steht unter der Lizenz Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International.

Nächste Lektion

105.1 Die Shell-Umgebung anpassen und verwenden (105.1 Lektion 3)

Nächste Lektion lesen

Linux Professional Insitute Inc. Alle Rechte vorbehalten. Besuchen Sie die LPI Learning Website: https://learning.lpi.org
Dieses Werk steht unter der Lizenz Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International.

LPI ist eine Non-Profit-Organisation.

© 2022 Linux Professional Institute (LPI) ist eine globale Organisation für Zertifizierungsstandards und zur Karriereplanung für Open-Source-Profis. Mit mehr als 200.000 Zertifikatsinhabern ist es die weltweit erste und größte herstellerneutrale Linux- und Open-Source-Zertifizierungsstelle. LPI verfügt über zertifizierte Fachleute in über 180 Ländern, bietet Prüfungen in mehreren Sprachen an und hat Hunderte von Trainingspartnern.

Unser Ziel ist es, wirtschaftliche und kreative Möglichkeiten für alle zu ermöglichen, indem wir Open-Source-Wissens- und Kompetenzzertifizierungen allgemein zugänglich machen.

  • LinkedIn
  • flogo-RGB-HEX-Blk-58 Facebook
  • Twitter
  • Kontaktieren Sie uns
  • Datenschutz und Cookie-Richtlinien

Haben Sie einen Fehler entdeckt oder möchten Sie helfen, diese Seite zu verbessern? Lassen Sie es uns wissen.

© 1999–2022 The Linux Professional Institute Inc. Alle Rechte vorbehalten.