105.1 Lektion 3

105.1 Lektion 3

Zertifikat:

LPIC-1

Version:

5.0

Thema:

105 Shells und Shell-Skripte

Lernziel:

105.1 Die Shell-Umgebung anpassen und verwenden

Lektion:

3 von 3

Einführung

Nachdem wir in den vorangegangenen Lektionen Shells, Startskripte und Variablen behandelt haben, werden wir das ganze Thema der Anpassung der Shell abrunden, indem wir einen Blick auf zwei sehr interessante Shell-Elemente werfen: Aliasse und Funktionen. Tatsächlich ist es die gesamte Gruppe der Variablen, Aliasse und Funktionen – und ihr Wechselspiel –, die die Shell-Umgebung ausmacht.

Die größte Stärke dieser beiden flexiblen und zeitsparenden Shell-Konzepte hat mit Kapselung zu tun: Sie bieten die Möglichkeit, unter einem einzigen Befehl eine Reihe sich wiederholender oder wiederkehrender Befehle zusammenzufassen.

Aliasse erstellen

Ein Alias ist ein Ersatzname für einen oder mehrere Befehle. Er kann wie ein regulärer Befehl ausgeführt werden, führt aber stattdessen einen anderen Befehl gemäß der Aliasdefinition aus.

Die Syntax für die Deklaration von Aliassen ist recht einfach. Aliasse werden deklariert, indem das Schlüsselwort alias, gefolgt von der Aliaszuweisung, übergeben wird. Die Aliaszuweisung wiederum besteht aus dem Aliasnamen, einem Gleichheitszeichen und einem oder mehreren Befehlen:

alias alias_name=command(s)

Zum Beispiel:

$ alias oldshell=sh

Dieser Alias startet eine Instanz der ursprünglichen Shell sh, wenn der Benutzer oldshell in das Terminal eingibt:

$ oldshell
$

Die Stärke von Aliassen liegt darin, dass wir kurze Versionen langer Befehle schreiben können:

$ alias ls='ls --color=auto'
Note

Für Informationen über ls und seine Farben geben Sie man dir_colors in das Terminal ein.

Ebenso können wir Aliasse für eine Reihe verketteter Befehle erstellen — das Semikolon (;) dient als Trennzeichen. Erstellen wir beispielsweise einen Alias, der uns Informationen über den Ort der ausführbaren Datei git und deren Version gibt:

$ alias git_info='which git;git --version'

Um den Alias aufzurufen, geben wir seinen Namen in das Terminal ein:

$ git_info
/usr/bin/git
git version 2.7.4

Der Befehl alias erstellt eine Liste aller im System verfügbaren Aliasse:

$ alias
alias git-info='which git;git --version'
alias ls='ls --color=auto'
alias oldshell='sh'

Der Befehl unalias entfernt Aliasnamen. Geben wir unalias git-info ein, sehen wir, wie unser Alias aus der Auflistung verschwindet:

$ unalias git-info
$ alias
alias ls='ls --color=auto'
alias oldshell='sh'

Wie in einer früheren Lektion mit alias hi='echo We salute you.' gesehen, müssen wir Befehle in Anführungszeichen (entweder einfach oder doppelt) einschließen, wenn diese — als Folge von Argumenten oder Parametern — Leerzeichen enthalten:

$ alias greet='echo Hello world!'
$ greet
Hello world!

Befehle mit Leerzeichen schließen auch solche mit Optionen ein:

$ alias ll='ls -al'

Jetzt listet ll alle Dateien — auch die versteckten (a) — im Langformat (l) auf.

Wir können Variablen in Aliassen referenzieren:

$ reptile=uromastyx
$ alias greet='echo Hello $reptile!'
$ greet
Hello uromastyx!

Die Variable kann auch innerhalb des Alias zugewiesen werden:

$ alias greet='reptile=tortoise; echo Hello $reptile!'
$ greet
Hello tortoise!

Mit \ machen wir einen Alias unwirksam:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ \where?
-bash: where?: command not found

Das Escapen eines Alias ist nützlich, wenn ein Alias den gleichen Namen wie ein regulärer Befehl hat. In diesem Fall hat der Alias Vorrang vor dem ursprünglichen Befehl, der jedoch durch das Escapen des Alias weiterhin zugänglich ist.

Ebenso können wir einen Alias in einen anderen Alias einfügen:

$ where?
/home/user2
$ alias my_home=where?
$ my_home
/home/user2

Auch eine Funktion lässt sich in einen Alias einfügen, wie im Folgenden zu sehen.

Erweiterung und Auswertung von Anführungszeichen in Aliassen

Wenn Sie Anführungszeichen mit Umgebungsvariablen verwenden, machen einfache Anführungszeichen die Erweiterung dynamisch:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ cd Music
$ where?
/home/user2/Music

Bei doppelten Anführungszeichen erfolgt die Expansion jedoch statisch:

$ alias where?="echo $PWD"
$ where?
/home/user2
$ cd Music
$ where?
/home/user2

Persistenz von Aliassen: Startup-Skripte

Genau wie bei den Variablen müssen wir unsere Aliasse in Initialisierungsskripten ablegen, die beim Start aufgerufen werden, damit sie persistent sind. Wie wir bereits wissen, ist ~/.bashrc eine geeignete Datei für Benutzer, um ihre persönlichen Aliasse zu speichern. Wahrscheinlich finden Sie dort bereits einige Aliasse — die meisten davon auskommentiert und bereit, durch Entfernen des führenden # verwendet zu werden:

$ grep alias .bashrc
# enable color support of ls and also add handy aliases
    alias ls='ls --color=auto'
    #alias dir='dir --color=
    #alias vdir='vdir --color=
    #alias grep='grep --color=
    #alias fgrep='fgrep --color'
    #alias egrep='egrep --color=
# some more ls aliases
#ll='ls -al'
#alias la='ls -A'
#alias l='ls -CF'
# ~/.bash_aliases, instead of adding them here directly.
if [ -f ~/.bash_aliases ]; then
   . ~/.bash_aliases

Die letzten drei Zeilen bieten die Möglichkeit, eine eigene Aliasdatei (~/.bash_aliases) anzulegen und diese bei jedem Systemstart von .bashrc zu sourcen. Legen wir also eine solche Datei an und befüllen sie:

###########
# .bash_aliases:
# a file to be populated by the user's personal aliases (and sourced by ~/.bashrc).
###########
alias git_info='which git;git --version'
alias greet='echo Hello world!'
alias ll='ls -al'
alias where?='echo $PWD'

Funktionen erstellen

Im Vergleich zu Aliassen sind Funktionen deutlich flexibler, besonders wenn es darum geht, das Potenzial der speziellen eingebauten Variablen und Positionsparameter der Bash auszunutzen. Sie eignen sich auch hervorragend, um mit Flusskontrollstrukturen wie Schleifen oder bedingten Anweisungen zu arbeiten. Stellen Sie sich eine Funktion als einen Befehl vor, der Logik in Form von Blöcken oder Sammlungen anderer Befehle enthält.

Zwei Wege zum Erstellen von Funktionen

Es gibt zwei gültige Strukturen, um Funktionen zu definieren.

Mit dem Schlüsselwort function

Zum einen über das Schlüsselwort function, gefolgt von dem Namen der Funktion und den Befehlen, eingeschlossen von geschweiften Klammern:

function function_name {
command #1
command #2
command #3
.
.
.
command #n
}
Mit ()

Alternativ lassen wir das Schlüsselwort function weg und setzen stattdessen zwei Klammern direkt hinter dem Namen der Funktion:

function_name() {
command #1
command #2
command #3
.
.
.
command #n
}

Es ist üblich, Funktionen in Dateien oder Skripten zu speichern. Sie können sie jedoch auch direkt in die Shell-Eingabeaufforderung schreiben, wobei jeder Befehl in einer eigenen Zeile steht — beachten Sie PS2 (>), das eine neue Zeile nach einem Zeilenumbruch anzeigt:

$ greet() {
> greeting="Hello world!"
> echo $greeting
> }

In jedem Fall — und unabhängig von der gewählten Syntax — gilt: Wenn wir auf Zeilenumbrüche verzichten und eine Funktion in nur einer Zeile schreiben wollen, müssen die Befehle durch Semikola getrennt werden (beachten Sie auch das Semikolon nach dem letzten Befehl):

$ greet() { greeting="Hello world!"; echo $greeting; }

bash hat sich nicht beschwert, als wir die Eingabetaste gedrückt haben, also ist unsere Funktion bereit, aufgerufen zu werden, und zwar über ihren Namen, den wir in das Terminal eingeben:

$ greet
Hello world!

Genau wie bei Variablen und Aliassen müssen wir Funktionen, die über Systemneustarts hinweg erhalten bleiben sollen, in Shell-Initialisierungsskripte wie /etc/bash.bashrc (global) oder ~/.bashrc (lokal) aufnehmen.

Warning

Nachdem Sie Aliasse oder Funktionen zu einem Startskript hinzugefügt haben, sollten Sie solche Dateien entweder mit . oder source erneut einlesen, damit die Änderungen wirksam werden — andernfalls müssen Sie sich ab- und wieder anmelden oder das System neu starten.

Spezielle eingebaute Bash-Variablen

Die Bourne Again Shell verfügt über einen Satz spezieller Variablen, die besonders für Funktionen und Skripte nützlich sind. Sie sind speziell, weil sie nur referenziert, aber nicht zugewiesen werden können. Hier ist eine Liste der wichtigsten:

$?

Die Referenz dieser Variablen liefert den Status des zuletzt ausgeführten Befehls. Der Wert 0 bedeutet Erfolg:

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $?
0

Ein anderer Wert als 0 bedeutet Fehler:

user1@debian:~$ ps aux |rep bash
-bash: rep: command not found
user1@debian:~$ echo $?
127
$$

Liefert die Shell-PID (Prozess-ID):

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $$
420
$!

Liefert die PID des letzten Hintergrundjobs:

$ ps aux | grep bash &
[1] 663
$ user2      420  0.0  0.4  21156  5012 pts/0    Ss+  17:10   0:00 -bash
user2      663  0.0  0.0  12784   972 pts/0    S    18:08   0:00 grep bash
^C
[1]+  Done                   ps aux | grep bash
$ echo $!
663
Note

Denken Sie daran, dass das kaufmännische Und (&) verwendet wird, um Prozesse im Hintergrund zu starten.
Positionsparameter $0 bis $9

Erweitert zu den Parametern oder Argumenten, die an die Funktion (Alias oder Skript) übergeben wurden — $0 erweitert zum Namen des Skripts oder der Shell.

Erstellen wir eine Funktion, um Positionsparameter zu demonstrieren — beachten Sie PS2 (>), das neue Zeilen nach Zeilenumbrüchen anzeigt:

$ special_vars() {
> echo $0
> echo $1
> echo $2
> echo $3
}

Jetzt rufen wir die Funktion (special_vars) auf und übergeben ihr drei Parameter (debian, ubuntu, zorin):

$ special_vars debian ubuntu zorin
-bash
debian
ubuntu
zorin

Es funktioniert wie erwartet.

Warning

Die Übergabe von Positionsparametern an Aliasse ist zwar technisch möglich, aber keineswegs funktional, da bei Aliassen Positionsparameter immer am Ende übergeben werden:

$ alias great_editor='echo $1 is a great text editor'
$ great_editor emacs
is a great text editor emacs

Weitere spezielle eingebaute Variablen der Bash sind:

$#

Liefert die Anzahl der an den Befehl übergebenen Argumente.

$@, $*

Liefern die an den Befehl übergebenen Argumente.

$_

Liefert (unter anderem) den letzten Parameter oder den Namen des Skripts (siehe man bash, um mehr zu erfahren):

Variablen in Funktionen

Natürlich können Sie Variablen auch innerhalb von Funktionen nutzen.

Um das zu beweisen, erstellen wir diesmal eine leere Datei mit dem Namen funed und legen die folgende Funktion darin ab:

editors() {

editor=emacs

echo "My editor is: $editor. $editor is a fun text editor."
}

Wie Sie vielleicht schon vermutet haben, müssen wir die Datei zuerst einlesen, um die Funktion aufrufen zu können:

$ . funed

Jetzt können wir testen:

$ editors
My editor is emacs. emacs is a fun text editor.

Wie erwartet, muss die Variable editor zuerst gesetzt werden, damit die Funktion editors richtig funktioniert. Der Gültigkeitsbereich dieser Variable ist lokal für die aktuelle Shell, und wir können sie so lange referenzieren, wie die Sitzung andauert:

$ echo $editor
emacs

Neben lokalen Variablen können wir auch Umgebungsvariablen in unsere Funktion aufnehmen:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
}

editors

Beachten Sie, dass wir dieses Mal die Funktion aus der Datei selbst heraus aufrufen (editors in der letzten Zeile). Auf diese Weise wird die Funktion auch aufgerufen, wenn wir die Datei einlesen — alles auf einmal:

$ . funed
The text editor of user2 is: emacs.

Positionsparameter in Funktionen

Ähnlich verhält es sich mit Positionsparametern.

Wir können diese an Funktionen aus der Datei oder dem Skript heraus übergeben (beachten Sie die letzte Zeile: editors tortoise):

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Wir lesen die Datei ein und zeigen deren Funktionalität:

$ . funed
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Wir können auch Positionsparameter an Funktionen auf der Kommandozeile übergeben. Um das zu zeigen, löschen wir die letzte Zeile der Datei:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

Dann müssen wir die Datei erneut einlesen:

$ . funed

Schließlich rufen wir die Funktion mit tortoise als Positionsparameter $1 in der Kommandozeile auf:

$ editors tortoise
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Funktionen in Skripten

Funktionen sind meist in Bash-Skripten zu finden.

Unsere Datei funed in ein Skript zu verwandeln (wir werden es funed.sh nennen) ist simpel:

#!/bin/bash

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Das war’s! Wir haben nur zwei Zeilen hinzugefügt:

  • Die erste Zeile ist der Shebang und definiert, welches Programm das Skript interpretieren wird: #!/bin/bash. Seltsamerweise ist dieses Programm bash selbst.

  • Die letzte Zeile ist einfach der Aufruf der Funktion.

Jetzt bleibt nur noch eins zu tun — wir müssen das Skript ausführbar machen:

$ chmod +x funed.sh

Jetzt ist es bereit, ausgeführt zu werden:

$ ./funed.sh
The text editor of user2 is: emacs.
Bash is not a tortoise shell.
Note

In den nächsten Lektionen werden Sie alles über Shellscripting lernen.

Eine Funktion innerhalb eines Alias

Wie bereits angesprochen, können wir eine Funktion in einen Alias einfügen:

$ alias great_editor='gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }; gr8_ed'

Dieser lange Aliaswert verdient eine Erklärung. Lassen Sie ihn uns aufschlüsseln:

  • Zunächst ist da die Funktion selbst: gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }

  • Der letzte Befehl in der Funktion — unset -f gr8_ed — hebt die Funktion auf, damit sie nach dem Aufruf des Alias nicht in der aktuellen bash-Sitzung verbleibt.

  • Zu guter Letzt müssen wir für einen erfolgreichen Alias-Aufruf auch die Funktion gr8_ed aufrufen.

Lassen Sie uns den Alias aufrufen und zeigen, dass er funktioniert:

$ great_editor emacs
emacs is a great text editor

Wie oben in unset -f gr8_ed gezeigt, wird der Befehl unset nicht nur zum Zurücksetzen von Variablen, sondern auch von Funktionen verwendet. Tatsächlich gibt es spezielle Schalter oder Optionen:

unset -v

für Variablen

unset -f

für Funktionen

Ohne Schalter versucht unset zunächst, eine Variable zurückzusetzen, und — falls dies fehlschlägt — danach eine Funktion.

Eine Funktion innerhalb einer Funktion

Nehmen wir nun an, wir wollen jedes Mal, wenn sich user2 am System anmeldet, zwei Dinge mitteilen:

  • Hallo sagen und einen Texteditor empfehlen.

  • Da der Nutzer viele Videodateien im Format Matroska im Ordner $HOME/Video abzulegen scheint, wollen wir eine Warnung ausgeben.

Dafür haben wir die folgenden zwei Funktionen in /home/user2/.bashrc aufgenommen:

Die erste Funktion (check_vids) übernimmt die Überprüfung von .mkv-Dateien und die Warnung:

check_vids() {
    ls -1 ~/Video/*.mkv > /dev/null 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than 5 video files in your Video folder.\nThanks."
    else
	echo -e "You do not have any videos in the Video folder. You can keep up to 5.\nThanks."
    fi
}

check_vids macht drei Dinge:

  • Es listet die mkv-Dateien in ~/Video auf und sendet die Ausgabe — und alle Fehler — in den sogenannten bit-bucket (/dev/null).

  • Es testet die Ausgabe des vorherigen Befehls auf Erfolg.

  • Je nach Ergebnis des Tests wird eine von zwei Meldungen ausgegeben.

Die zweite Funktion ist eine modifizierte Version unserer Funktion editors:

editors() {

editor=emacs

echo "Hi, $USER!"
echo "$editor is more than a text editor!"

check_vids
}

editors

Es ist wichtig, zwei Dinge zu beachten:

  • Der letzte Befehl von editors ruft check_vids auf, so dass beide Funktionen verkettet werden: Die Begrüßung, die Empfehlung und die Überprüfung und Warnung werden nacheinander ausgeführt.

  • editors selbst ist der Funktionsaufruf, daher wird er in der letzten Zeile (editors) aufgerufen.

Wir melden uns als user2 an und sehen, dass es funktioniert:

# su - user2
Hi, user2!
emacs is more than a text editor!
Remember, you must not keep more than 5 video files in your Video folder.
Thanks.

Geführte Übungen

  1. Vervollständigen Sie die Tabelle mit “Ja” oder “Nein” unter Berücksichtigung der Möglichkeiten von Aliassen und Funktionen:

    Merkmal Aliasse? Funktionen?

    Lokale Variablen können verwendet werden

    Umgebungsvariablen können verwendet werden

    Kann mit \ escapet werden

    Kann rekursiv sein

    Sehr produktiv bei Verwendung mit Positionsparametern

  2. Wie lautet der Befehl, der alle Aliasnamen in Ihrem System auflistet?

  3. Schreiben Sie einen Alias namens logg, der alle ogg-Dateien in ~/Music auflistet — eine pro Zeile:

  4. Rufen Sie den Alias auf, um zu zeigen, dass er funktioniert:

  5. Ändern Sie nun den Alias so, dass er den Benutzer der Sitzung und einen Doppelpunkt vor der Auflistung ausgibt:

  6. Rufen Sie den Alias erneut auf, um zu zeigen, dass auch diese neue Version funktioniert:

  7. Listen Sie alle Aliasse erneut auf und prüfen Sie, ob Ihr Alias logg in der Liste erscheint:

  8. Entfernen Sie den Alias:

  9. Betrachten Sie die Spalten “Aliasname” und “Aliasbefehl(e)” und ordnen Sie die Aliasse ihren Werten korrekt zu:

    Aliasname Aliasbefehl(e) Aliaszuordnung

    b

    bash

    bash_info

    which bash + echo "$BASH_VERSION"

    kernel_info

    uname -r

    greet

    echo Hi, $USER!

    computer

    pc=slimbook + echo My computer is a $pc

  10. Schreiben Sie als root eine Funktion namens my_fun in /etc/bash.bashrc. Die Funktion muss dem Benutzer Hallo sagen und ihm mitteilen, wie sein Pfad lautet. Rufen Sie sie so auf, dass der Benutzer bei jeder Anmeldung beide Meldungen erhält:

  11. Melden Sie sich als user2 an, um zu prüfen, ob es funktioniert:

  12. Schreiben Sie die gleiche Funktion in nur einer Zeile:

  13. Rufen Sie die Funktion auf:

  14. Setzen Sie die Funktion zurück:

  15. Dies ist eine modifizierte Version der Funktion special_vars:

    $ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }

    Dies ist der Befehl, mit dem wir die Funktion aufrufen:

    $ special_vars2 crying cockles and mussels alive alive oh

    Wie lauten die Ausgaben?

    Referenz Wert

    echo $#

    echo $_

    echo $1

    echo $4

    echo $6

    echo $7

    echo $_

    echo $@

    echo $?

  16. Basierend auf der Beispielfunktion (check_vids) im Abschnitt “Eine Funktion innerhalb einer Funktion” schreiben Sie eine Funktion namens check_music, die Sie in ein bash Startskript einbinden, das Positionsparameter akzeptiert, so dass wir sie leicht ändern können:

    • Typ der zu prüfenden Datei: ogg

    • Verzeichnis, in dem die Dateien gespeichert werden: ~/Music

    • Typ der Datei, die aufbewahrt wird: music

    • Anzahl der zu speichernden Dateien: 7

Offene Übungen

  1. Schreibgeschützte Funktionen sind solche, deren Inhalt wir nicht verändern können. Recherchieren Sie zu readonly functions und vervollständigen Sie die folgende Tabelle:

    Funktionsname Schreibgeschützt machen Alle schreibgeschützten Funktionen auflisten

    my_fun

  2. Suchen Sie im Internet, wie Sie PS1 modifizieren und alles andere, was Sie benötigen, um eine Funktion namens fyi zu schreiben (die in einem Startskript platziert werden soll), die dem Benutzer die folgenden Informationen liefert:

    • Name des Benutzers

    • Homeverzeichnis

    • Name des Hosts

    • Betriebssystemtyp

    • Suchpfad für ausführbare Dateien

    • Mailverzeichnis

    • wie oft die Mail geprüft wird

    • wie viele Shells tief die aktuelle Sitzung ist

    • Eingabeaufforderung (Sie sollten diese so abändern, dass sie <user>@<host-date> anzeigt)

Zusammenfassung

In dieser Lektion haben Sie gelernt:

  • Sowohl Aliasse als auch Funktionen sind wichtige Konzepte der Shell, die es uns ermöglichen, wiederkehrende Codeblöcke zu kapseln.

  • Aliasse sind nützlich, um kürzere Versionen von langen und/oder komplizierten Befehlen zu schreiben.

  • Funktionen sind Prozeduren, die Logik implementieren und uns erlauben, Aufgaben zu automatisieren, besonders wenn sie in Skripten verwendet werden.

  • Die Syntax zum Schreiben von Aliassen und Funktionen.

  • Wie man verschiedene Befehle mit Hilfe des Semikola (;) verkettet.

  • Wie man Anführungszeichen bei Aliassen richtig verwendet.

  • Wie man Aliasse und Funktionen persistent macht.

  • Spezielle eingebaute Variablen der Bash: $?, $$, $!, Positionsparameter ($0-$9), $#, $@, $* und $_.

  • Wie man Variablen und Positionsparameter mit Funktionen verwendet.

  • Wie man Funktionen in Skripten verwendet.

  • Wie man eine Funktion über einen Alias aufruft.

  • Wie man eine Funktion von einer anderen Funktion aus aufruft.

  • Die Grundlagen zum Erstellen eines bash-Skripts.

In dieser Lektion verwendete Befehle und Schlüsselwörter:

alias

Erstellt einen Alias.

unalias

Entfernt einen Alias.

cd

Wechselt das Verzeichnis.

grep

Liefert Zeilen, die einem Muster entsprechen.

function

Schlüsselwort der Shell zum Erstellen von Funktionen.

.

Liest eine Datei ein.

source

Liest eine Datei ein.

ps

Liefert eine Momentaufnahme der aktuell laufenden Prozesse.

echo

Gibt eine Textzeile aus.

chmod

Ändert die Modus-Bits einer Datei und macht sie z.B. ausführbar.

unset

Entfernt gesetzte Variablen und Funktionen.

su

Ändert die Benutzer-ID oder macht zum Superuser.

Lösungen zu den geführten Übungen

  1. Vervollständigen Sie die Tabelle mit “Ja” oder “Nein” unter Berücksichtigung der Möglichkeiten von Aliassen und Funktionen:

    Merkmal Aliasse? Funktionen?

    Lokale Variablen können verwendet werden

    Ja

    Ja

    Umgebungsvariablen können verwendet werden

    Ja

    Ja

    Kann mit \ escapet werden

    Ja

    Nein

    Kann rekursiv sein

    Ja

    Ja

    Sehr produktiv bei Verwendung mit Positionsparametern

    Nein

    Ja

  2. Wie lautet der Befehl, der alle Aliasnamen in Ihrem System auflistet?

    alias

  3. Schreiben Sie einen Alias namens logg, der alle ogg-Dateien in ~/Music auflistet — eine pro Zeile:

    alias logg='ls -1 ~/Music/*ogg'

  4. Rufen Sie den Alias auf, um zu zeigen, dass er funktioniert:

    logg

  5. Ändern Sie nun den Alias so, dass er den Benutzer der Sitzung und einen Doppelpunkt vor der Auflistung ausgibt:

    alias logg='echo $USER:; ls -1 ~/Music/*ogg'

  6. Rufen Sie den Alias erneut auf, um zu zeigen, dass auch diese neue Version funktioniert:

    logg

  7. Listen Sie alle Aliasse erneut auf und prüfen Sie, ob Ihr Alias logg in der Liste erscheint:

    alias

  8. Entfernen Sie den Alias:

    unalias logg

  9. Betrachten Sie die Spalten “Aliasname” und “Aliasbefehl(e)” und ordnen Sie die Aliasse ihren Werten korrekt zu:

    Aliasname Aliasbefehl(e) Aliaszuordnung

    b

    bash

    alias b=bash

    bash_info

    which bash + echo "$BASH_VERSION"

    alias bash_info='which bash; echo "$BASH_VERSION"'

    kernel_info

    uname -r

    alias kernel_info='uname -r'

    greet

    echo Hi, $USER!

    alias greet='echo Hi, $USER'

    computer

    pc=slimbook + echo My computer is a $pc

    alias computer='pc=slimbook; echo My computer is a $pc'
    Note

    Einfache Anführungszeichen können auch durch doppelte Anführungszeichen ersetzt werden.

  10. Schreiben Sie als root eine Funktion namens my_fun in /etc/bash.bashrc. Die Funktion muss dem Benutzer Hallo sagen und ihm mitteilen, wie sein Pfad lautet. Rufen Sie sie so auf, dass der Benutzer bei jeder Anmeldung beide Meldungen erhält:

    Option A:

    my_fun() {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun

    Option B:

    function my_fun {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun

  11. Melden Sie sich als user2 an, um zu prüfen, ob es funktioniert:

    su - user2

  12. Schreiben Sie die gleiche Funktion in nur einer Zeile:

    Option A:

    my_fun() { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

    Option B:

    function my_fun { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

  13. Rufen Sie die Funktion auf:

    my_fun

  14. Setzen Sie die Funktion zurück:

    unset -f my_fun

  15. Dies ist eine modifizierte Version der Funktion special_vars:

    $ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }

    Dies ist der Befehl, mit dem wir die Funktion aufrufen:

    $ special_vars2 crying cockles and mussels alive alive oh

    Wie lauten die Ausgaben?

    Referenz Wert

    echo $#

    7

    echo $_

    7

    echo $1

    crying

    echo $4

    mussels

    echo $6

    alive

    echo $7

    oh

    echo $_

    oh

    echo $@

    crying cockles and mussels alive alive oh

    echo $?

    0

  16. Basierend auf der Beispielfunktion (check_vids) im Abschnitt “Eine Funktion innerhalb einer Funktion” schreiben Sie eine Funktion namens check_music, die Sie in ein bash Startskript einbinden, das Positionsparameter akzeptiert, so dass wir sie leicht ändern können:

    • Typ der zu prüfenden Datei: ogg

    • Verzeichnis, in dem die Dateien gespeichert werden: ~/Music

    • Typ der Datei, die aufbewahrt wird: music

    • Anzahl der zu speichernden Dateien: 7

      check_music() {
    ls -1 ~/$1/*.$2 > ~/.mkv.log 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than $3 $4 files in your $1 folder.\nThanks."
    else
	 echo -e "You do not have any $4 files in the $1 folder. You can keep up to $3.\nThanks."
    fi
}

check_music Music ogg 7 music

Lösungen zu den offenen Übungen

  1. Schreibgeschützte Funktionen sind solche, deren Inhalt wir nicht verändern können. Recherchieren Sie zu readonly functions und vervollständigen Sie die folgende Tabelle:

    Funktionsname

    Schreibgeschützt machen

    Alle schreibgeschützten Funktionen auflisten

    my_fun

    readonly -f my_fun

    readonly -f

  2. Suchen Sie im Internet, wie Sie PS1 modifizieren und alles andere, was Sie benötigen, um eine Funktion namens fyi zu schreiben (die in einem Startskript platziert werden soll), die dem Benutzer die folgenden Informationen liefert:

    • Name des Benutzers

    • Homeverzeichnis

    • Name des Hosts

    • Betriebssystemtyp

    • Suchpfad für ausführbare Dateien

    • Mailverzeichnis

    • wie oft die Mail geprüft wird

    • wie viele Shells tief die aktuelle Sitzung ist

    • Eingabeaufforderung (Sie sollten diese so abändern, dass sie <user>@<host-date> anzeigt)

      fyi() {
    echo -e "For your Information:\n
    Username: $USER
    Home directory: $HOME
    Host: $HOSTNAME
    Operating System: $OSTYPE
    Path for executable files: $PATH
    Your mail directory is $MAIL and is searched every $MAILCHECK seconds.
    The current level of your shell is: $SHLVL"
    PS1="\u@\h-\d "
}

fyi

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.