Textdateien in Red Hat Enterprise Linux bearbeiten

Einführung

In diesem Lab erwerben Sie grundlegende Fähigkeiten für die Verwaltung von Textdateien und die Anpassung Ihrer Shell-Umgebung in Linux. Sie lernen, wie Sie Standardausgabe und -fehlerströme in Dateien umleiten, verschiedene Ströme kombinieren und leistungsstarke Befehlspipelines erstellen, um Aufgaben zu automatisieren.

Darüber hinaus werden Sie die Grundlagen der Textbearbeitung mit Vim, einem weit verbreiteten und leistungsstarken Texteditor, kennenlernen. Schließlich lernen Sie, Shell-Variablen und Aliase zu konfigurieren und zu nutzen, um Ihre Kommandozeilen-Erfahrung zu personalisieren und die Produktivität zu steigern.

Standardausgabe in Dateien umleiten

In diesem Schritt lernen Sie, wie Sie die Standardausgabe von Befehlen in Dateien umleiten. Dies ist eine grundlegende Fähigkeit in der Linux-Systemadministration, mit der Sie Befehlsergebnisse für spätere Analysen, Protokollierung oder weitere Verarbeitung erfassen können.

Die Shell verwendet spezielle Dateideskriptoren (File Descriptors), um Eingabe und Ausgabe zu verwalten. Die gebräuchlichsten sind:

0: Standardeingabe (stdin) - Typischerweise von der Tastatur.
1: Standardausgabe (stdout) - Typischerweise auf dem Terminalbildschirm.
2: Standardfehler (stderr) - Typischerweise auf dem Terminalbildschirm für Fehlermeldungen.

Wir konzentrieren uns in diesem Abschnitt auf das Umleiten von stdout.

Überschreiben einer Datei mit `>`

Der Operator > leitet die Standardausgabe eines Befehls in eine angegebene Datei um. Wenn die Datei nicht existiert, wird sie erstellt. Wenn die Datei bereits existiert, wird ihr Inhalt überschrieben.

Beginnen wir damit, eine einfache Textdatei mit dem aktuellen Datum und der Uhrzeit zu erstellen.

Stellen Sie zunächst sicher, dass Sie sich im project-Ordner Ihres Home-Verzeichnisses befinden.
```
cd ~/project
```
```
[labex@host project]$
```
Verwenden Sie nun den Befehl date und leiten Sie seine Ausgabe in eine neue Datei namens current_datetime.txt um.
```
date > current_datetime.txt
```
Dieser Befehl führt date aus, speichert das Datum aber anstelle der Ausgabe auf Ihrem Terminal in current_datetime.txt.
Überprüfen Sie den Inhalt der Datei mit dem Befehl cat.
```
cat current_datetime.txt
```
```
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY
```
Die Ausgabe zeigt das aktuelle Datum und die Uhrzeit, ähnlich dem obigen Beispiel.
Versuchen wir nun, die Ausgabe von echo in dieselbe Datei umzuleiten. Dadurch wird der vorherige Inhalt überschrieben.
```
echo "This is a new line of text." > current_datetime.txt
```
Überprüfen Sie den Dateiinhalt erneut.
```
cat current_datetime.txt
```
```
This is a new line of text.
```
Wie Sie sehen können, wurden das ursprüngliche Datum und die Uhrzeit durch die neue Textzeile ersetzt.

Anhängen an eine Datei mit `>>`

Der Operator >> leitet die Standardausgabe eines Befehls in eine angegebene Datei um und hängt den neuen Inhalt an das Ende der Datei an. Wenn die Datei nicht existiert, wird sie erstellt.

Fügen wir unserer Datei current_datetime.txt weiteren Inhalt hinzu.

Hängen Sie eine weitere Textzeile an current_datetime.txt an.
```
echo "This line is appended." >> current_datetime.txt
```
Zeigen Sie den Inhalt der Datei an.
```
cat current_datetime.txt
```
```
This is a new line of text.
This line is appended.
```
Beachten Sie, dass die neue Zeile nach dem vorhandenen Inhalt hinzugefügt wurde.
Fügen wir das aktuelle Datum und die Uhrzeit erneut an.
```
date >> current_datetime.txt
```

Überprüfen Sie den Dateiinhalt noch einmal.

cat current_datetime.txt

This is a new line of text.
This line is appended.
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY

Das Datum und die Uhrzeit stehen jetzt am Ende der Datei.

Umleiten der Ausgabe anderer Befehle

Sie können die Ausgabe fast jedes Befehls umleiten. Versuchen wir, die Ausgabe von ls und wc umzuleiten.

Leiten Sie die Ausgabe von ls -l (Long Listing Format) in eine Datei namens file_list.txt um.
```
ls -l > file_list.txt
```
Untersuchen Sie den Inhalt von file_list.txt.
```
cat file_list.txt
```
```
total 4
-rw-r--r-- 1 labex labex 80 Jun  4 07:04 current_datetime.txt
-rw-r--r-- 1 labex labex  0 Jun  4 07:04 file_list.txt
```
Diese Datei enthält jetzt die detaillierte Auflistung der Dateien in Ihrem aktuellen Verzeichnis. Die genauen Dateigrößen und Zeitstempel variieren je nachdem, wann Sie die Befehle ausführen.
Zählen wir nun die Anzahl der Zeilen in file_list.txt mit wc -l und leiten wir diese Anzahl in eine andere Datei, line_count.txt, um.
```
wc -l file_list.txt > line_count.txt
```
Zeigen Sie den Inhalt von line_count.txt an.
```
cat line_count.txt
```
```
3 file_list.txt
```
Die Ausgabe zeigt, dass file_list.txt 3 Zeilen hat (einschließlich der Zeile total und der beiden Dateieinträge).

Dies schließt den ersten Teil des Umleitens der Standardausgabe ab. Sie haben gelernt, wie Sie Dateien mit > erstellen und überschreiben und mit >> anhängen können.

Standardfehler umleiten und Ströme kombinieren

In diesem Schritt lernen Sie, wie Sie Standardfehler (stderr) umleiten und wie Sie stdout und stderr in einem einzigen Stream kombinieren. Dies ist entscheidend für die Verwaltung von Fehlermeldungen, die von Befehlen generiert werden, sodass Sie diese bei Bedarf protokollieren oder verwerfen können.

Denken Sie daran, dass stderr der Dateideskriptor 2 ist. Wir verwenden 2> zum Umleiten von Fehlermeldungen.

Umleiten von Standardfehlern in eine Datei

Manchmal erzeugen Befehle Fehlermeldungen, die Sie getrennt von ihrer Standardausgabe erfassen möchten.

Stellen Sie sicher, dass Sie sich in Ihrem Verzeichnis ~/project befinden.
```
cd ~/project
```
```
[labex@host project]$
```
Versuchen wir, den Inhalt eines nicht existierenden Verzeichnisses aufzulisten. Dies generiert eine Fehlermeldung.
```
ls non_existent_directory
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Sie können die Fehlermeldung direkt auf dem Terminal sehen.
Leiten wir diese Fehlermeldung nun in eine Datei namens errors.log um.
```
ls non_existent_directory 2> errors.log
```
Dieses Mal sehen Sie die Fehlermeldung nicht auf Ihrem Terminal.
Überprüfen Sie den Inhalt von errors.log.
```
cat errors.log
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Die Fehlermeldung wird jetzt in der Datei gespeichert.

Verwerfen von Standardfehlern

Oft möchten Sie möglicherweise einen Befehl ausführen, der störende Fehlermeldungen erzeugt, die Sie nicht interessieren. In solchen Fällen können Sie stderr nach /dev/null umleiten. /dev/null ist eine spezielle Gerätedatei, die alle Daten verwirft, die in sie geschrieben werden.

Versuchen Sie den Befehl ls erneut mit dem nicht existierenden Verzeichnis, aber verwerfen Sie diesmal den Fehler.
```
ls non_existent_directory 2> /dev/null
```
Sie sehen keine Ausgabe auf dem Terminal, und es wird keine Fehlermeldung in einer Datei gespeichert.

Kombinieren von Standardausgabe und Standardfehlern

Es gibt Situationen, in denen Sie sowohl stdout als auch stderr in derselben Datei erfassen möchten. Dies kann auf verschiedene Arten erfolgen.

Methode 1: `> file 2>&1`

Diese Methode leitet stdout in eine Datei um und leitet dann stderr an denselben Ort wie stdout um. Die Reihenfolge 2>&1 ist wichtig: Sie bedeutet "leite Dateideskriptor 2 (stderr) an denselben Ort wie Dateideskriptor 1 (stdout) um".

Erstellen wir einen Befehl, der sowohl Standardausgabe als auch Standardfehler erzeugt. Wir verwenden find, um nach einer Datei in einem Verzeichnis zu suchen, in dem wir Berechtigungen haben, und in einem Verzeichnis, in dem wir keine haben.
```
find ~/project /root -name "current_datetime.txt" > combined_output.log 2>&1
```
Hier erzeugt find ~/project -name "current_datetime.txt" stdout (falls gefunden), und find /root -name "current_datetime.txt" erzeugt wahrscheinlich stderr aufgrund von Berechtigungsproblemen.
Untersuchen Sie die Datei combined_output.log.
```
cat combined_output.log
```
```
/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
```
Sie können sowohl die erfolgreiche Ausgabe (der Pfad zur Datei) als auch die Fehlermeldung in derselben Datei erfassen.

Methode 2: `&> file` (Bash-spezifisch)

Bash bietet eine Kurzschreibweise zum Kombinieren von stdout und stderr in einer Datei: &>. Dies entspricht > file 2>&1.

Versuchen wir denselben find-Befehl mit der Kurzschreibweise &>.

find ~/project /root -name "file_list.txt" &> combined_output_shorthand.log

Überprüfen Sie den Inhalt von combined_output_shorthand.log.
```
cat combined_output_shorthand.log
```
```
/home/labex/project/file_list.txt
find: ‘/root’: Permission denied
```
Das Ergebnis ist dasselbe wie bei der vorherigen Methode, was die Bequemlichkeit von &> demonstriert.

Anhängen von kombinierten Strömen

Genau wie bei stdout können Sie kombinierte stdout und stderr mit >> file 2>&1 oder &>> file an eine Datei anhängen.

Hängen Sie weitere Ausgaben und Fehler an combined_output.log an.

find ~/project /root -name "line_count.txt" >> combined_output.log 2>&1

Zeigen Sie die aktualisierte combined_output.log an.

cat combined_output.log

/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
/home/labex/project/line_count.txt
find: ‘/root’: Permission denied

Die neue Ausgabe und die Fehler werden an den vorhandenen Inhalt angehängt.

Sie haben nun erfolgreich gelernt, wie Sie Standardfehler umleiten und wie Sie Standardausgabe und Standardfehler in einer einzigen Datei kombinieren. Dieses Wissen ist für robuste Skripterstellung und Systemadministrationsaufgaben unerlässlich.

Kommando-Pipelines erstellen und verstehen

In diesem Schritt lernen Sie Befehlspipelines kennen, eine leistungsstarke Funktion in der Linux-Shell, mit der Sie mehrere Befehle miteinander verketten können. Die Ausgabe eines Befehls wird zur Eingabe des nächsten, was eine komplexe Datenverarbeitung und -manipulation ermöglicht.

Der Pipe-Operator | (vertikaler Strich) wird verwendet, um Befehle in einer Pipeline zu verbinden. Er leitet die Standardausgabe (stdout) des Befehls auf seiner linken Seite an die Standardeingabe (stdin) des Befehls auf seiner rechten Seite um.

Grundlegende Pipelines

Beginnen wir mit einem einfachen Beispiel, um zu verstehen, wie Pipelines funktionieren.

Stellen Sie sicher, dass Sie sich in Ihrem Verzeichnis ~/project befinden.
```
cd ~/project
```
```
[labex@host project]$
```

Listen wir zunächst die Dateien im aktuellen Verzeichnis auf.

ls

combined_output.log
combined_output_shorthand.log
current_datetime.txt
errors.log
file_list.txt
line_count.txt

Leiten wir nun die Ausgabe von ls an den Befehl wc -l weiter, der die Anzahl der Zeilen zählt, die er empfängt.
```
ls | wc -l
```
```
6
```
Der Befehl ls listet die Dateien auf, und seine Ausgabe (jeder Dateiname in einer neuen Zeile) wird als Eingabe an wc -l weitergeleitet, das dann diese Zeilen zählt und Ihnen effektiv mitteilt, wie viele Dateien/Verzeichnisse sich am aktuellen Ort befinden.
Versuchen wir einen weiteren häufigen Anwendungsfall: Weiterleiten von ls -l an less für eine seitenweise Ausgabe. Dies ist nützlich, wenn ein Befehl zu viel Ausgabe erzeugt, um auf einen einzigen Bildschirm zu passen.
```
ls -l /usr/bin | less
```
```
total 200000
-rwxr-xr-x 1 root root 12345 Jan XX HH:MM [filename]
... (press 'q' to quit less) ...
```
Der Befehl ls -l /usr/bin listet alle Dateien in /usr/bin mit detaillierten Informationen auf. Diese Ausgabe wird dann an less gesendet, sodass Sie sie seitenweise durchblättern können. Drücken Sie q, um less zu beenden.

Filtern der Ausgabe mit `grep`

Der Befehl grep wird häufig in Pipelines verwendet, um Zeilen zu filtern, die einem bestimmten Muster entsprechen.

Listen wir alle Prozesse auf, die auf dem System ausgeführt werden, indem wir ps aux verwenden, und filtern wir dann nach Prozessen, die sich auf bash beziehen.
```
ps aux | grep bash
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
labex     5678  0.0  0.0   9876  5432 pts/0    S+   HH:MM   0:00 grep bash
```
Der Befehl ps aux listet alle laufenden Prozesse auf. Seine Ausgabe wird an grep bash weitergeleitet, das dann nur die Zeilen anzeigt, die das Wort "bash" enthalten. Möglicherweise sehen Sie zwei Zeilen: eine für Ihre aktuelle Bash-Shell und eine für den Befehl grep selbst.
Um den Befehl grep von der Ausgabe auszuschließen, können Sie grep -v (invert match) verwenden oder Ihr Muster verfeinern. Versuchen wir grep -v grep.
```
ps aux | grep bash | grep -v grep
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
```
Jetzt wird nur der tatsächliche Bash-Prozess angezeigt.

Verwenden von `sort` und `uniq`

sort wird verwendet, um Textzeilen zu sortieren, und uniq wird verwendet, um wiederholte Zeilen zu melden oder wegzulassen. Sie werden oft zusammen verwendet.

Erstellen wir eine Datei mit einigen unsortierten, wiederholten Wörtern.
```
echo -e "apple\nbanana\napple\norange\nbanana" > fruits.txt
```

Zeigen Sie den Inhalt von fruits.txt an.

cat fruits.txt

apple
banana
apple
orange
banana

Sortieren wir nun die Zeilen in fruits.txt.

cat fruits.txt | sort

apple
apple
banana
banana
orange

Um nur die eindeutigen sortierten Wörter zu erhalten, leiten Sie die Ausgabe von sort an uniq weiter.
```
cat fruits.txt | sort | uniq
```
```
apple
banana
orange
```
Diese Pipeline sortiert zuerst die Zeilen, dann entfernt uniq doppelte benachbarte Zeilen.

Der Befehl `tee`

Der Befehl tee ist in Pipelines etwas Besonderes. Er liest die Standardeingabe, schreibt sie in die Standardausgabe und schreibt sie gleichzeitig in eine oder mehrere Dateien. Es ist wie eine "T"-Verzweigung in einem Rohr, die es ermöglicht, dass Daten in zwei Richtungen fließen.

Listen wir die Dateien auf und speichern wir die Ausgabe in ls_output.txt, während wir sie auch auf dem Bildschirm anzeigen.

ls -l | tee ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output_shorthand.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM current_datetime.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM errors.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM file_list.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM fruits.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM line_count.txt
-rw-r--r-- 1 labex labex 0 Jan XX HH:MM ls_output.txt

Sie sehen die Ausgabe von ls -l auf Ihrem Terminal, und eine Datei namens ls_output.txt wird mit demselben Inhalt erstellt.

Überprüfen Sie den Inhalt von ls_output.txt.

cat ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (same as above) ...

Sie können auch tee -a verwenden, um die Ausgabe an eine Datei anzuhängen.
```
echo "--- End of list ---" | tee -a ls_output.txt
```
```
--- End of list ---
```
Die Zeile "--- End of list ---" wird auf dem Terminal ausgegeben und an ls_output.txt angehängt.

Überprüfen Sie die aktualisierte ls_output.txt.

cat ls_output.txt

total 24
... (previous ls -l output) ...
--- End of list ---

Pipelines sind unglaublich vielseitig und bilden das Rückgrat vieler leistungsstarker Shell-Skripte und Einzeiler-Befehle. Durch die Kombination einfacher Befehle können Sie komplexe Datentransformationen effizient durchführen.

Textdateien mit Vim-Grundlagen bearbeiten

In diesem Schritt lernen Sie die grundlegenden Operationen von Vim kennen, einem leistungsstarken und weit verbreiteten Texteditor in der Linux-Umgebung. Vim arbeitet in verschiedenen Modi, was für Anfänger etwas herausfordernd sein kann, aber die Beherrschung der Grundlagen wird Ihre Produktivität erheblich steigern.

Vim ist ein modaler Editor, was bedeutet, dass er verschiedene Modi für verschiedene Aufgaben hat:

Normal Mode (Command Mode): Dies ist der Standardmodus, wenn Sie Vim öffnen. In diesem Modus werden Tastenanschläge als Befehle interpretiert (z. B. Bewegen des Cursors, Löschen von Text, Kopieren von Text).
Insert Mode: In diesem Modus wird alles, was Sie eingeben, in die Datei eingefügt. Sie wechseln vom Normal Mode in den Insert Mode, indem Sie i (am Cursor einfügen), a (nach dem Cursor anhängen), o (neue Zeile darunter öffnen) usw. drücken. Um in den Normal Mode zurückzukehren, drücken Sie Esc.
Visual Mode: In diesem Modus können Sie Textblöcke für Operationen wie Kopieren, Ausschneiden oder Löschen auswählen. Sie wechseln vom Normal Mode in den Visual Mode, indem Sie v (zeichenweise), Shift+V (zeilenweise) oder Ctrl+V (blockweise) drücken. Drücken Sie Esc, um in den Normal Mode zurückzukehren.
Command-Line Mode (Ex Mode): Dieser Modus wird zum Ausführen von Befehlen verwendet, die typischerweise mit einem Doppelpunkt (:) beginnen, wie z. B. Speichern (:w), Beenden (:q) oder Suchen (/). Sie wechseln von Normal Mode in diesen Modus, indem Sie :drücken.

Stellen Sie sicher, dass Sie sich in Ihrem Verzeichnis ~/project befinden.
```
cd ~/project
```
```
[labex@host project]$
```
Öffnen Sie eine neue Datei namens my_document.txt mit vim.
```
vim my_document.txt
```
Ihr Terminal zeigt nun die Vim-Oberfläche an. Sie befinden sich im Normal Mode.
Im Normal Mode können Sie mit den Pfeiltasten oder h (links), j (unten), k (oben), l (rechts) navigieren. Da die Datei leer ist, gibt es noch nicht viel zu navigieren.

Insert Mode: Hinzufügen von Text

Um mit der Eingabe zu beginnen, müssen Sie den Insert Mode aufrufen. Drücken Sie i (zum Einfügen).
Sie sollten -- INSERT -- unten links in Ihrem Terminal sehen, was anzeigt, dass Sie sich im Insert Mode befinden.

Geben Sie die folgenden Zeilen ein:

This is the first line.
This is the second line.
This is the third line.

Um den Insert Mode zu verlassen und in den Normal Mode zurückzukehren, drücken Sie die Taste Esc.
Die Anzeige -- INSERT -- sollte verschwinden.

Speichern und Beenden

Geben Sie im Normal Mode :w ein und drücken Sie Enter, um die Datei zu speichern.
```
:w
```
Sie sollten unten my_document.txt [New] 3L, 60B written sehen, was das Speichern bestätigt.
Um Vim zu beenden, geben Sie :q ein und drücken Sie Enter.
```
:q
```
Sie werden zu Ihrer Shell-Eingabeaufforderung zurückkehren.

Überprüfen Sie den Inhalt von my_document.txt mit cat.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.

Bearbeiten vorhandener Dateien

Öffnen Sie my_document.txt erneut.
```
vim my_document.txt
```
Bewegen Sie im Normal Mode Ihren Cursor an den Anfang der zweiten Zeile (mit j oder den Pfeiltasten).
Drücken Sie Shift+V, um den Visual Line Mode aufzurufen. Die gesamte zweite Zeile wird hervorgehoben.
Drücken Sie y, um die ausgewählte Zeile zu "yank" (kopieren).
Bewegen Sie Ihren Cursor an das Ende der dritten Zeile (mit j oder den Pfeiltasten).
Drücken Sie p, um die geyankte Zeile unterhalb der aktuellen Zeile einzufügen (zu "put").
Die zweite Zeile erscheint nun erneut als vierte Zeile.
Löschen wir nun eine Zeile. Bewegen Sie Ihren Cursor auf die vierte Zeile (die, die Sie gerade eingefügt haben).
Drücken Sie dd (doppeltes d), um die gesamte Zeile zu löschen.
Um Ihre letzte Änderung rückgängig zu machen, drücken Sie u. Die gelöschte Zeile wird wieder angezeigt.
Um in einem Befehl zu speichern und zu beenden, geben Sie :wq ein und drücken Sie Enter.
```
:wq
```
Überprüfen Sie den Inhalt von my_document.txt erneut.
```
cat my_document.txt
```
```
This is the first line.
This is the second line.
This is the third line.
This is the second line.
```
Die Datei sollte nun vier Zeilen haben, wobei die zweite Zeile dupliziert wurde.

Verwerfen von Änderungen

Manchmal nehmen Sie Änderungen vor und entscheiden sich, diese nicht zu speichern.

Öffnen Sie my_document.txt erneut.
```
vim my_document.txt
```
Rufen Sie den Insert Mode auf, indem Sie i drücken.
Fügen Sie am Ende eine neue Zeile hinzu:
```
This line should not be saved.
```
Drücken Sie Esc, um in den Normal Mode zurückzukehren.
Versuchen Sie, mit :q zu beenden.
```
:q
```
Vim warnt Sie: E37: No write since last change (add ! to override). Dies bedeutet, dass Sie ungespeicherte Änderungen haben.
Um ohne Speichern zu beenden, geben Sie :q! ein und drücken Sie Enter.
```
:q!
```
Sie werden zur Shell-Eingabeaufforderung zurückkehren, und Ihre Änderungen werden verworfen.
Überprüfen Sie den Inhalt von my_document.txt.
```
cat my_document.txt
```
```
This is the first line.
This is the second line.
This is the third line.
This is the second line.
```
Die letzte Zeile, die Sie hinzugefügt haben, sollte nicht vorhanden sein.

Sie haben nun die grundlegendsten Operationen in Vim behandelt: Öffnen von Dateien, Einfügen von Text, Navigieren, Speichern, Beenden und Verwerfen von Änderungen. Dies sind die wesentlichen Fähigkeiten, um mit Vim zu beginnen.

Shell-Variablen und Aliase konfigurieren und verwenden

In diesem Schritt lernen Sie, wie Sie Shell-Variablen und Aliase konfigurieren und verwenden. Dies sind leistungsstarke Funktionen, mit denen Sie Ihre Shell-Umgebung anpassen, Daten speichern und Verknüpfungen für häufig verwendete Befehle erstellen können, wodurch Ihre Effizienz in der Befehlszeile erheblich gesteigert wird.

Shell-Variablen

Shell-Variablen sind benannte Entitäten, die Daten speichern. Sie können Zahlen, Text oder andere Daten speichern, die von der Shell oder von Programmen verwendet werden können, die innerhalb der Shell ausgeführt werden.

Stellen Sie sicher, dass Sie sich in Ihrem Verzeichnis ~/project befinden.
```
cd ~/project
```
```
[labex@host project]$
```
Festlegen einer lokalen Variable: Erstellen wir eine einfache Variable namens MY_MESSAGE.
```
MY_MESSAGE="Hello, LabEx!"
```
Beachten Sie, dass sich keine Leerzeichen um das = -Zeichen befinden.
Zugreifen auf eine Variable: Um auf den Wert einer Variable zuzugreifen, stellen Sie ihrem Namen ein $-Zeichen voran.
```
echo $MY_MESSAGE
```
```
Hello, LabEx!
```
Variablenexpansion mit geschweiften Klammern: Manchmal müssen Sie den Variablennamen eindeutig abgrenzen, insbesondere wenn er von anderen Zeichen gefolgt wird. Verwenden Sie hierfür geschweifte Klammern {}.
```
echo "The message is: ${MY_MESSAGE}."
```
```
The message is: Hello, LabEx!.
```
Wenn Sie die Klammern weglassen, könnte die Shell MY_MESSAGE. als Variablennamen interpretieren, der nicht existiert.
Auflisten aller festgelegten Variablen: Sie können den Befehl set verwenden, um alle aktuell festgelegten Shell-Variablen und -Funktionen aufzulisten. Diese Ausgabe kann sehr lang sein, daher wird sie oft an less weitergeleitet.
```
set | less
```
```
BASH=/usr/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:progcomp:promptvars:sourcepath
... (press 'q' to quit less) ...
```
Drücken Sie q, um less zu beenden.
Aufheben der Festlegung einer Variable: Um eine Variable zu entfernen, verwenden Sie den Befehl unset.
```
unset MY_MESSAGE
```
Überprüfen Sie, ob die Variable nicht mehr festgelegt ist.
```
echo $MY_MESSAGE
```
Sie sollten eine leere Zeile sehen, die anzeigt, dass die Variable nicht festgelegt ist.

Umgebungsvariablen

Umgebungsvariablen sind eine spezielle Art von Shell-Variablen, die von untergeordneten Prozessen geerbt werden. Dies bedeutet, dass jedes Programm oder Skript, das von Ihrer aktuellen Shell aus gestartet wird, Zugriff auf diese Variablen hat. Sie werden typischerweise verwendet, um die Umgebung für Anwendungen zu konfigurieren.

Festlegen einer Umgebungsvariablen: Verwenden Sie den Befehl export, um eine Variable zu einer Umgebungsvariablen zu machen.
```
export EDITOR=vim
```
Dadurch wird die Umgebungsvariable EDITOR festgelegt, die viele Programme verwenden, um Ihren bevorzugten Texteditor zu bestimmen.
Auflisten von Umgebungsvariablen: Verwenden Sie den Befehl env, um nur die Umgebungsvariablen aufzulisten.
```
env | grep EDITOR
```
```
EDITOR=vim
```
Aufheben des Exports einer Variable: Sie können eine Variable ohne Aufhebung ihrer Festlegung mit export -n wieder exportieren. Dadurch wird sie wieder zu einer lokalen Variable.
```
export -n EDITOR
```
Überprüfen Sie, ob es sich nicht mehr um eine Umgebungsvariable handelt.
```
env | grep EDITOR
```
Sie sollten keine Ausgabe sehen. Es ist jedoch immer noch eine lokale Variable:
```
echo $EDITOR
```
```
vim
```
Um sie vollständig zu entfernen, verwenden Sie unset.
```
unset EDITOR
```

Shell-Aliase

Aliase sind Verknüpfungen für Befehle. Sie ermöglichen es Ihnen, einen neuen Befehl zu definieren, der sich zu einem längeren Befehl oder einer Befehlssequenz erweitert. Dies ist sehr nützlich für häufig verwendete Befehle mit vielen Optionen.

Erstellen eines Alias: Erstellen wir einen Alias für ls -l, um ihn kürzer zu machen.
```
alias ll='ls -l'
```
Beachten Sie die einfachen Anführungszeichen um den Befehl, um sicherzustellen, dass er als einzelne Zeichenkette behandelt wird.

Verwenden eines Alias: Jetzt können Sie einfach ll anstelle von ls -l eingeben.

ll

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (output of ls -l) ...

Auflisten von Aliassen: Verwenden Sie den Befehl alias ohne Argumente, um alle definierten Aliase anzuzeigen.
```
alias
```
```
alias ll='ls -l'
```
Möglicherweise sehen Sie andere Standardaliase, abhängig von Ihrer Shell-Konfiguration.
Erstellen eines komplexeren Alias: Sie können auch Aliase für Befehle mit Argumenten oder mehreren Befehlen erstellen.
```
alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'
```
Hier zeigt myip Ihre primäre IP-Adresse an. Beachten Sie das \$2, um das $-Zeichen zu escapen, damit es an awk übergeben und nicht von der Shell interpretiert wird, wenn der Alias definiert wird.
Testen Sie den Alias myip.
```
myip
```
```
172.17.0.2
```
(Ihre IP-Adresse kann variieren)
Aufheben der Festlegung eines Alias: Um einen Alias zu entfernen, verwenden Sie den Befehl unalias.
```
unalias ll
```

Überprüfen Sie, ob der Alias entfernt wurde.

alias

alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'

ll sollte nicht mehr in der Liste stehen.

Shell-Variablen und Aliase sind temporär und gehen verloren, wenn Sie Ihre Terminal-Sitzung schließen. Um sie dauerhaft zu machen, müssen Sie sie zu den Konfigurationsdateien Ihrer Shell (z. B. ~/.bashrc oder ~/.profile) hinzufügen, was in fortgeschritteneren Themen behandelt wird.

Zusammenfassung

In diesem Lab haben Sie grundlegende Linux-Befehlszeilenkenntnisse erlernt, die für die Verwaltung von Textdateien und der Shell-Umgebung unerlässlich sind. Sie begannen mit der Beherrschung der Ausgabenumleitung, insbesondere mit > zum Überschreiben von Dateien und >> zum Anhängen von Inhalten, wodurch Sie Befehlsergebnisse für die Protokollierung oder weitere Verarbeitung erfassen konnten. Sie haben auch die Umleitung von Standardfehlern (2>) und die Kombination von Standardausgabe und -fehlern (&>) untersucht, um die gesamte Befehlsausgabe effektiv zu verwalten.

Darüber hinaus haben Sie Kenntnisse im Aufbau und Verständnis von Befehlspipelines mit dem Operator | erworben, wodurch Sie Befehle verketten und Daten sequenziell verarbeiten können. Sie wurden in die grundlegende Textbearbeitung mit Vim eingeführt und behandelten wesentliche Befehle zum Einfügen, Speichern und Beenden von Dateien. Schließlich lernten Sie, wie Sie Shell-Variablen zum Speichern von Daten konfigurieren und verwenden und Aliase erstellen, um häufig verwendete Befehle zu vereinfachen, wodurch Ihre Effizienz und Anpassung der Befehlszeile verbessert werden.