Nachdem wir die grundlegenden Konzepte der Kommandozeileninteraktion kennengelernt haben, ist es an der Zeit, unsere ersten Shell-Skripte zu erstellen. Shell-Scripting ermöglicht es uns, Abfolgen von Befehlen in Dateien zu speichern und diese Befehle automatisiert auszuführen – eine Fähigkeit, die für System-Administratoren und Entwickler gleichermaßen wertvoll ist. In diesem Abschnitt lernen wir Schritt für Schritt, wie man ein einfaches Shell-Skript erstellt, es ausführbar macht und ausführt.
Ein Shell-Skript ist im Wesentlichen eine Textdatei, die eine Sequenz von Befehlen enthält, die von der Shell interpretiert und ausgeführt werden. Diese Befehle könnten Sie genauso gut direkt im Terminal eingeben – aber durch die Speicherung in einer Datei können Sie:
Shell-Skripte sind in ihrer einfachsten Form nichts anderes als Sammlungen von Kommandozeilenbefehlen, die in der Reihenfolge ausgeführt werden, in der sie in der Datei stehen.
Lassen Sie uns ein einfaches “Hello, World!”-Skript erstellen, das
klassische erste Programm in jeder Programmiersprache. Dazu benötigen
wir einen Texteditor. In der Linux-Welt stehen viele Texteditoren zur
Verfügung, darunter nano, vim,
gedit oder VS Code. Für Einsteiger ist
nano wegen seiner Einfachheit oft die beste Wahl.
Öffnen Sie ein Terminal und geben Sie ein:
nano mein_erstes_skript.shDer Editor öffnet sich und Sie können nun Text eingeben. Schreiben Sie folgende Zeilen:
#!/bin/bash
# Mein erstes Shell-Skript
echo "Hello, World!"
echo "Heute ist $(date)"
echo "Mein aktuelles Verzeichnis ist $(pwd)"Lassen Sie uns diesen Code Zeile für Zeile durchgehen:
#!/bin/bash - Dies ist die sogenannte “Shebang”-Zeile,
die wir später genauer erklären werden. Sie teilt dem System mit,
welcher Interpreter für dieses Skript verwendet werden soll.# Mein erstes Shell-Skript - Dies ist ein Kommentar.
Alles nach dem #-Zeichen wird von der Shell ignoriert und
dient nur der Dokumentation.echo "Hello, World!" - Der Befehl echo
gibt Text auf dem Bildschirm aus.echo "Heute ist $(date)" - Hier nutzen wir
Befehlssubstitution, um das aktuelle Datum einzufügen.echo "Mein aktuelles Verzeichnis ist $(pwd)" - Ähnlich
wie oben, aber mit dem aktuellen Arbeitsverzeichnis.Speichern Sie die Datei in nano, indem Sie
Ctrl+O drücken, dann Enter, und
verlassen Sie den Editor mit Ctrl+X.
Die erste Zeile eines Shell-Skripts beginnt üblicherweise mit
#!, gefolgt vom Pfad zum Interpreter, der das Skript
ausführen soll. Diese spezielle Zeile wird als “Shebang” (manchmal auch
“hashbang”) bezeichnet.
#!/bin/bashWenn ein Skript mit dieser Zeile beginnt und Sie es direkt ausführen,
wird das Betriebssystem automatisch /bin/bash aufrufen und
ihm den Inhalt des Skripts zur Interpretation übergeben.
Andere häufige Shebang-Zeilen sind:
#!/bin/sh - Verwendet die Standard-System-Shell (oft
ein Symlink auf Bash oder Dash)#!/usr/bin/env bash - Sucht den Bash-Interpreter im
Systempfad, was portabler sein kann#!/bin/zsh - Verwendet die Z-Shell#!/usr/bin/python3 - Für Python-SkripteDie Shebang-Zeile ist nur relevant, wenn das Skript direkt ausgeführt
wird. Wenn Sie das Skript explizit mit einem Interpreter aufrufen (z.B.
bash mein_erstes_skript.sh), wird die Shebang-Zeile
ignoriert.
In Unix/Linux-Systemen müssen Dateien explizit als ausführbar
markiert werden, bevor sie direkt ausgeführt werden können. Dazu
verwenden wir den chmod-Befehl (change mode), der die
Zugriffsberechtigungen einer Datei ändert:
chmod +x mein_erstes_skript.shDas +x fügt die Ausführungsberechtigung für alle
Benutzer hinzu (Eigentümer, Gruppe und andere). Wenn Sie die Ausführung
auf bestimmte Benutzer beschränken möchten, können Sie spezifischer
sein:
chmod u+x mein_erstes_skript.sh # Nur für den Eigentümer (user)
chmod g+x mein_erstes_skript.sh # Nur für die Gruppe (group)
chmod o+x mein_erstes_skript.sh # Nur für andere Benutzer (others)Sie können die aktuellen Berechtigungen einer Datei mit dem Befehl
ls -l überprüfen:
$ ls -l mein_erstes_skript.sh
-rwxr-xr-x 1 benutzer gruppe 123 Sep 10 15:30 mein_erstes_skript.shDie Berechtigungen werden am Anfang der Ausgabe angezeigt:
rwx für den Eigentümer (lesen, schreiben, ausführen),
r-x für die Gruppe (lesen, ausführen) und r-x
für andere (lesen, ausführen).
Es gibt mehrere Wege, ein Shell-Skript auszuführen:
bash mein_erstes_skript.shDiese Methode funktioniert immer, unabhängig von den Ausführungsberechtigungen oder der Shebang-Zeile.
./mein_erstes_skript.shDer ./ teilt der Shell mit, dass sie das Skript im
aktuellen Verzeichnis suchen soll. Ohne diesen Präfix würde die Shell
nur in den Verzeichnissen suchen, die in der
PATH-Umgebungsvariable definiert sind.
PATH liegt:Wenn Sie Ihr Skript in ein Verzeichnis verschieben, das im
PATH ist (z.B. /usr/local/bin oder
~/bin, sofern konfiguriert), können Sie es direkt
aufrufen:
mein_erstes_skript.shDies ist nützlich für Skripte, die Sie regelmäßig von überall im System ausführen möchten.
Die PATH-Umgebungsvariable ist eine Liste von
Verzeichnissen, die durch Doppelpunkte getrennt sind. Wenn Sie einen
Befehl ohne expliziten Pfad eingeben, sucht die Shell in jedem dieser
Verzeichnisse nach einer ausführbaren Datei mit diesem Namen.
Sie können den Inhalt Ihres PATH anzeigen mit:
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/home/benutzer/binUm ein Verzeichnis für Ihre eigenen Skripte zum PATH
hinzuzufügen, können Sie Ihre .bashrc- oder
.bash_profile-Datei (für Bash-Benutzer) bearbeiten und
folgende Zeile hinzufügen:
export PATH="$HOME/bin:$PATH"Dies fügt ein Verzeichnis bin in Ihrem Home-Verzeichnis
zum Pfad hinzu. Vergessen Sie nicht, das Verzeichnis zu erstellen und
Ihre Shell neu zu starten oder die Konfiguration neu zu laden:
mkdir -p ~/bin
source ~/.bashrc # oder ~/.bash_profileJetzt können Sie Ihre Skripte in ~/bin ablegen und sie
von überall aufrufen.
Lassen Sie uns ein praktischeres Beispiel erstellen: ein Skript, das
ein Verzeichnis sichert (backup). Erstellen Sie eine neue Datei namens
backup.sh:
nano backup.shUnd fügen Sie folgenden Inhalt ein:
#!/bin/bash
# Backup-Skript für ein Verzeichnis
# Verwendung: ./backup.sh [Quellverzeichnis]
# Überprüfen, ob ein Verzeichnispfad angegeben wurde
if [ $# -eq 0 ]; then
echo "Fehler: Kein Verzeichnis angegeben"
echo "Verwendung: $0 [Quellverzeichnis]"
exit 1
fi
# Das zu sichernde Verzeichnis
SOURCE_DIR=$1
# Überprüfen, ob das Verzeichnis existiert
if [ ! -d "$SOURCE_DIR" ]; then
echo "Fehler: Das Verzeichnis '$SOURCE_DIR' existiert nicht."
exit 1
fi
# Zielverzeichnis für das Backup
BACKUP_DIR=~/backups
# Aktuelles Datum und Zeit für den Dateinamen
DATUM=$(date +%Y-%m-%d_%H-%M-%S)
# Dateiname des Backups
BACKUP_FILE="$BACKUP_DIR/backup_${DATUM}.tar.gz"
# Backupverzeichnis erstellen, falls es nicht existiert
mkdir -p "$BACKUP_DIR"
# Backup erstellen
echo "Erstelle Backup von $SOURCE_DIR..."
tar -czf "$BACKUP_FILE" "$SOURCE_DIR"
# Überprüfen, ob das Backup erfolgreich war
if [ $? -eq 0 ]; then
echo "Backup erfolgreich erstellt: $BACKUP_FILE"
# Größe des Backups anzeigen
du -h "$BACKUP_FILE"
else
echo "Fehler beim Erstellen des Backups"
exit 1
fiMachen Sie das Skript ausführbar:
chmod +x backup.shFühren Sie es mit einem Verzeichnis als Argument aus:
./backup.sh ~/DokumenteDieses Skript zeigt bereits einige fortgeschrittenere Konzepte, die
wir in späteren Kapiteln detaillierter behandeln werden: - Überprüfung
von Benutzerargumenten - Verzweigungen mit if-Anweisungen -
Verwendung von Variablen für bessere Wartbarkeit - Überprüfung des
Exit-Status eines Befehls - Dynamische Generierung von Dateinamen
Wenn Sie ein Skript ausführen, geschieht Folgendes:
Kernel-Interpretation der Shebang-Zeile: Wenn
Sie ein Skript direkt ausführen (z.B. ./skript.sh), liest
der Kernel die Shebang-Zeile und übergibt den Rest der Datei an den
angegebenen Interpreter.
Shell wird gestartet: Eine neue Shell-Instanz wird gestartet, um das Skript auszuführen.
Skript wird gelesen: Die Shell liest das Skript Zeile für Zeile.
Befehle werden ausgeführt: Jeder Befehl wird in der angegebenen Reihenfolge ausgeführt, wobei Fehler je nach Skriptlogik behandelt werden.
Exit-Status wird zurückgegeben: Nachdem das
Skript abgeschlossen ist, gibt die Shell einen Exit-Status an die
aufrufende Shell zurück, normalerweise den Exit-Status des letzten
ausgeführten Befehls, sofern nicht explizit mit exit
festgelegt.
Hier sind einige häufige Probleme und ihre Lösungen:
chmod +x skript.shPATH oder
der Pfad ist falsch angegeben../skript.sh oder fügen Sie das
Verzeichnis zum PATH hinzu.dos2unix oder stellen Sie sicher, dass Ihr Editor
Unix-Zeilenenden (LF) verwendet.#!/bin/bash beginnt, aber Bash nicht unter
/bin/bash installiert ist.#!/usr/bin/env bash, um den
Bash-Interpreter im System-Pfad zu finden.Hier sind einige Empfehlungen für Ihre ersten Shell-Skripte:
Beginnen Sie immer mit einer Shebang-Zeile, um die verwendete Shell explizit anzugeben.
Fügen Sie Kommentare hinzu, um den Zweck des Skripts und komplexer Befehle zu erklären.
Wählen Sie aussagekräftige Dateinamen mit der
Erweiterung .sh für Shell-Skripte, um ihre Funktion klar zu
kommunizieren.
Testen Sie Ihre Skripte in einer kontrollierten Umgebung, bevor Sie sie in Produktionsumgebungen einsetzen.
Behandeln Sie Fehlerfälle, insbesondere wenn das Skript mit sensiblen Daten oder Systemressourcen arbeitet.
Fügen Sie Nutzungsinformationen hinzu, besonders für Skripte, die Parameter akzeptieren oder von anderen Benutzern verwendet werden könnten.
In diesem Praxisbeispiel werden wir Schritt für Schritt ein klassisches “Hello World”-Skript erstellen und ausführen. Dieses einfache Beispiel wird Ihnen die grundlegenden Elemente des Shell-Scriptings vermitteln und als Sprungbrett für komplexere Skripte dienen. Wir werden die einzelnen Schritte detailliert erläutern, sodass Sie auch ohne Vorkenntnisse folgen können.
Beginnen wir mit dem Erstellen einer neuen Textdatei. Öffnen Sie dazu ein Terminal und navigieren Sie zu einem Verzeichnis Ihrer Wahl, in dem Sie die Datei erstellen möchten. Für dieses Beispiel verwenden wir das Home-Verzeichnis:
cd ~Nun erstellen wir die Skriptdatei mit einem Texteditor. In diesem
Beispiel verwenden wir nano, einen benutzerfreundlichen
Editor, der auf den meisten Linux-Systemen vorinstalliert ist:
nano hello_world.shDieser Befehl öffnet den nano-Editor mit einer neuen
oder bestehenden Datei namens hello_world.sh. Die Endung
.sh ist nicht zwingend erforderlich, hat sich aber als
Konvention für Shell-Skripte etabliert und erleichtert die
Identifizierung.
In den geöffneten Editor geben Sie nun folgenden Code ein:
#!/bin/bash
# Mein erstes Shell-Skript
# Autor: Ihr Name
# Datum: Aktuelles Datum
echo "Hello, World!"
echo "Heute ist $(date)"
echo "Ich bin eingeloggt als $(whoami)"
echo "Willkommen in meinem ersten Shell-Skript!"Lassen Sie uns diesen Code im Detail betrachten:
Shebang-Zeile (#!/bin/bash): Diese
erste Zeile teilt dem System mit, welcher Interpreter für die Ausführung
des Skripts verwendet werden soll. In diesem Fall ist es die Bash-Shell,
die sich üblicherweise unter /bin/bash befindet.
Kommentare (Zeilen, die mit #
beginnen): Diese Zeilen werden von der Shell ignoriert und
dienen nur der Dokumentation. Es ist eine gute Praxis, zumindest
grundlegende Informationen wie den Zweck des Skripts, den Autor und das
Erstellungsdatum anzugeben.
echo-Befehle: Diese geben Text auf dem Bildschirm aus.
Befehlssubstitution ($(...)): Mit
dieser Syntax können wir die Ausgabe eines Befehls in einen String
einbetten. In unserem Beispiel:
$(date) wird durch das aktuelle Datum und die Uhrzeit
ersetzt$(whoami) wird durch den Benutzernamen ersetzt, unter
dem Sie eingeloggt sindDrücken Sie nach der Eingabe des Codes Ctrl+O (speichern), dann Enter (Dateinamen bestätigen) und schließlich Ctrl+X (Editor verlassen).
In Unix/Linux-Systemen muss eine Datei explizit als ausführbar
markiert werden, bevor sie direkt ausgeführt werden kann. Dies geschieht
mit dem chmod-Befehl (change mode):
chmod +x hello_world.shDas +x fügt die Ausführungsberechtigung zu den
bestehenden Berechtigungen hinzu. Sie können überprüfen, ob die
Berechtigung korrekt gesetzt wurde, indem Sie den folgenden Befehl
ausführen:
ls -l hello_world.shDie Ausgabe sollte ähnlich wie folgt aussehen:
-rwxr-xr-x 1 benutzer gruppe 157 Sep 15 14:30 hello_world.shDie Zeichenfolge am Anfang zeigt die Berechtigungen an. Das
x (drei davon in diesem Fall) steht für “ausführbar”
(executable). Die drei Berechtigungsgruppen stehen für den Eigentümer,
die Gruppe und alle anderen Benutzer.
Nun können wir unser Skript auf verschiedene Arten ausführen:
./hello_world.shDer ./ gibt an, dass die Datei im aktuellen Verzeichnis
gesucht werden soll. Die Shell würde sonst nur in den Verzeichnissen
suchen, die in der PATH-Umgebungsvariable definiert
sind.
bash hello_world.shDiese Methode funktioniert auch, wenn die Datei nicht als ausführbar markiert ist.
Nach der Ausführung des Skripts sollten Sie eine Ausgabe ähnlich der folgenden sehen:
Hello, World!
Heute ist Di 15. Sep 2024 14:35:42 CEST
Ich bin eingeloggt als benutzer
Willkommen in meinem ersten Shell-Skript!Die genaue Ausgabe variiert je nach Datum, Uhrzeit und Benutzernamen.
Nun, da wir ein funktionierendes Skript haben, können wir es erweitern. Öffnen Sie die Datei erneut im Editor:
nano hello_world.shUnd fügen Sie am Ende folgende Zeilen hinzu:
# Systeminformationen anzeigen
echo -e "\nEinige Systeminformationen:"
echo "------------------------"
echo "Betriebssystem: $(uname -s)"
echo "Kernel-Version: $(uname -r)"
echo "Hostname: $(hostname)"
echo "CPU-Informationen: $(grep "model name" /proc/cpuinfo | head -n 1 | cut -d ":" -f 2 | sed 's/^[ \t]*//')"
echo "Verfügbarer Speicher: $(free -h | grep Mem | awk '{print $4}')"Diese Erweiterung zeigt, wie wir verschiedene Systembefehle kombinieren können, um nützliche Informationen anzuzeigen:
uname -s gibt den Namen des Betriebssystems ausuname -r zeigt die Kernel-Versionhostname gibt den Namen des Computers zurückgrep, head,
cut und sed extrahiert die
CPU-Modellinformation aus /proc/cpuinfofree, grep und
awk zeigt den verfügbaren Arbeitsspeicher anSpeichern Sie die Datei und führen Sie das Skript erneut aus:
./hello_world.shDie erweiterte Ausgabe sollte nun auch die Systeminformationen enthalten.
Als nächstes machen wir unser Skript flexibler, indem wir Parameter hinzufügen. Bearbeiten Sie das Skript erneut:
nano hello_world.shUnd modifizieren Sie es wie folgt:
#!/bin/bash
# Erweitertes Hello-World-Skript
# Autor: Ihr Name
# Datum: Aktuelles Datum
# Prüfen, ob ein Name als Parameter übergeben wurde
if [ $# -eq 0 ]; then
# Kein Parameter angegeben, Standard-Benutzer verwenden
USER_NAME=$(whoami)
else
# Parameter verwenden
USER_NAME=$1
fi
echo "Hello, $USER_NAME!"
echo "Heute ist $(date)"
echo "Ich bin eingeloggt als $(whoami)"
echo "Willkommen in meinem ersten Shell-Skript!"
# Systeminformationen nur anzeigen, wenn -s oder --system als zweiter Parameter angegeben wurde
if [ "$2" = "-s" ] || [ "$2" = "--system" ]; then
echo -e "\nEinige Systeminformationen:"
echo "------------------------"
echo "Betriebssystem: $(uname -s)"
echo "Kernel-Version: $(uname -r)"
echo "Hostname: $(hostname)"
echo "CPU-Informationen: $(grep "model name" /proc/cpuinfo | head -n 1 | cut -d ":" -f 2 | sed 's/^[ \t]*//')"
echo "Verfügbarer Speicher: $(free -h | grep Mem | awk '{print $4}')"
fi
echo -e "\nSkript wurde ausgeführt am $(date +"%d.%m.%Y um %H:%M:%S")"In dieser erweiterten Version haben wir:
$# ist die Anzahl der Parameter)$1
ist der erste Parameter)-s oder --system als zweiter Parameter
angegeben wurdeSpeichern Sie die Datei und testen Sie die verschiedenen Ausführungsarten:
# Standard-Ausführung ohne Parameter
./hello_world.sh
# Mit Benutzernamen
./hello_world.sh "Max Mustermann"
# Mit Benutzernamen und Anzeige der Systeminformationen
./hello_world.sh "Max Mustermann" --system
# Nur Systeminformationen mit Standard-Benutzernamen
./hello_world.sh "" -sIn diesem Praxisbeispiel haben Sie gelernt:
if-Anweisungen
implementiertDieses einfache “Hello World”-Beispiel bildet die Grundlage für komplexere Skripte, die wir in den folgenden Kapiteln entwickeln werden. Es demonstriert bereits viele grundlegende Konzepte des Shell-Scriptings, die in praktisch jedem Skript zum Einsatz kommen.
Eine effiziente und angenehme Arbeit mit der Shell hängt maßgeblich von einer gut konfigurierten Umgebung ab. In dieser Übung werden Sie Ihre eigene Shell-Umgebung personalisieren, indem Sie benutzerdefinierte Einstellungen, Aliase und Funktionen erstellen. Dies wird nicht nur Ihre Produktivität steigern, sondern Ihnen auch ein tieferes Verständnis der Shell-Konfiguration vermitteln.
Bevor wir Änderungen vornehmen, sollten wir verstehen, welche Dateien die Shell beim Start lädt. Führen Sie die folgenden Befehle aus, um diese Dateien zu identifizieren und zu untersuchen:
# Anzeigen der globalen Bash-Konfigurationsdateien
ls -la /etc/bash.bashrc /etc/profile 2>/dev/null
ls -la /etc/profile.d/ 2>/dev/null
# Anzeigen der benutzerspezifischen Konfigurationsdateien
ls -la ~/.bash_profile ~/.bashrc ~/.profile ~/.bash_logout 2>/dev/nullHinweis: Die genauen Dateinamen und -pfade können je nach Distribution variieren.
Die wichtigsten Dateien für unsere Übung sind:
Erstellen Sie Sicherungskopien dieser Dateien, bevor Sie Änderungen vornehmen:
cp ~/.bashrc ~/.bashrc.bak
cp ~/.bash_profile ~/.bash_profile.bak 2>/dev/null
cp ~/.profile ~/.profile.bak 2>/dev/nullEin eigenes Bin-Verzeichnis ist ideal für persönliche Skripte, die Sie von überall aufrufen möchten.
mkdir -p ~/binPATH hinzu, indem Sie Ihre
~/.bashrc bearbeiten:echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrcsource ~/.bashrc# Skript erstellen
nano ~/bin/hello
# Folgenden Inhalt einfügen:
#!/bin/bash
echo "Hello from your personal script!"
# Ausführbar machen
chmod +x ~/bin/hellocd /tmp
helloWenn “Hello from your personal script!” angezeigt wird, wurde das Bin-Verzeichnis erfolgreich eingerichtet.
Aliase sind Abkürzungen für längere oder häufig verwendete Befehle. Erstellen Sie eine separate Datei für Ihre Aliase:
# Datei erstellen
nano ~/.bash_aliases
# Folgende Aliase einfügen:
# Navigation
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias ..='cd ..'
alias ...='cd ../..'
alias .3='cd ../../..'
alias .4='cd ../../../..'
# Sicherheit
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
# Netzwerk
alias myip='curl -s ifconfig.me'
alias ports='netstat -tulanp'
# Systeminfo
alias meminfo='free -m -l -t'
alias cpuinfo='lscpu'
alias diskspace='df -h'
# Git (falls installiert)
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'Aktivieren Sie diese Aliase, indem Sie Ihre ~/.bashrc
bearbeiten:
echo '
# Alias-Definitionen
if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi
' >> ~/.bashrcLaden Sie die aktualisierte Konfiguration:
source ~/.bashrcTesten Sie einige der Aliase, z.B. ll, ..
oder myip.
Für komplexere Aufgaben sind Funktionen leistungsfähiger als Aliase. Erstellen Sie eine Datei für Ihre Funktionen:
# Datei erstellen
nano ~/.bash_functions
# Folgende Funktionen einfügen:
# Verzeichnis erstellen und hineinwechseln
mkcd() {
mkdir -p "$1" && cd "$1"
}
# Schnelle Suche in Dateien
ftext() {
grep -r "$1" .
}
# Archiv extrahieren (unterstützt verschiedene Formate)
extract() {
if [ -f "$1" ] ; then
case "$1" in
*.tar.bz2) tar xjf "$1" ;;
*.tar.gz) tar xzf "$1" ;;
*.bz2) bunzip2 "$1" ;;
*.rar) unrar e "$1" ;;
*.gz) gunzip "$1" ;;
*.tar) tar xf "$1" ;;
*.tbz2) tar xjf "$1" ;;
*.tgz) tar xzf "$1" ;;
*.zip) unzip "$1" ;;
*.Z) uncompress "$1" ;;
*.7z) 7z x "$1" ;;
*) echo "'$1' kann nicht extrahiert werden" ;;
esac
else
echo "'$1' ist keine gültige Datei"
fi
}
# Backup-Funktion
backup() {
if [ -z "$1" ]; then
echo "Verwendung: backup <datei/verzeichnis>"
return 1
fi
timestamp=$(date +%Y%m%d_%H%M%S)
cp -r "$1" "$1"_backup_"$timestamp"
echo "Backup erstellt: $1_backup_$timestamp"
}Aktivieren Sie diese Funktionen in Ihrer ~/.bashrc:
echo '
# Funktionsdefinitionen
if [ -f ~/.bash_functions ]; then
. ~/.bash_functions
fi
' >> ~/.bashrcLaden Sie die aktualisierte Konfiguration:
source ~/.bashrcTesten Sie die Funktionen, z.B. mkcd test_dir,
backup wichtige_datei.txt oder
extract archiv.tar.gz (falls vorhanden).
Der Shell-Prompt (PS1) kann angepasst werden, um nützliche Informationen anzuzeigen und optisch ansprechender zu sein.
# Sichern des aktuellen Prompts
echo "# Original PS1: $PS1" >> ~/.bashrc
# Anpassen des Prompts
echo '
# Angepasster Prompt
PS1="\[\033[38;5;11m\]\u\[\033[0m\]@\[\033[38;5;39m\]\h\[\033[0m\]:\[\033[38;5;76m\]\w\[\033[0m\]\$ "
' >> ~/.bashrcDiese Einstellung färbt den Benutzernamen gelb, den Hostnamen blau und den aktuellen Pfad grün.
Für fortgeschrittene Benutzer, die Git verwenden, hier ein Prompt, der den Git-Branch anzeigt:
echo '
# Git-Status im Prompt anzeigen (wenn git installiert ist)
if command -v git &>/dev/null; then
parse_git_branch() {
git branch 2> /dev/null | sed -e "/^[^*]/d" -e "s/* \(.*\)/ (\1)/"
}
PS1="\[\033[38;5;11m\]\u\[\033[0m\]@\[\033[38;5;39m\]\h\[\033[0m\]:\[\033[38;5;76m\]\w\[\033[38;5;214m\]\$(parse_git_branch)\[\033[0m\]\$ "
fi
' >> ~/.bashrcLaden Sie die aktualisierte Konfiguration:
source ~/.bashrcUmgebungsvariablen beeinflussen das Verhalten von Programmen und der Shell selbst.
echo '
# Historieneinstellungen
export HISTSIZE=10000 # Anzahl der Befehle im Speicher
export HISTFILESIZE=10000 # Anzahl der gespeicherten Befehle
export HISTCONTROL=ignoreboth:erasedups # Keine Duplikate speichern
# Bevorzugte Programme
export EDITOR=nano # Standard-Editor
export VISUAL=nano # Visueller Editor
export PAGER=less # Pager für lange Ausgaben
# Lokalisierung
export LANG=de_DE.UTF-8 # Deutsche Lokalisierung mit UTF-8
export LC_ALL=de_DE.UTF-8 # Konsistente Lokalisierung
# Farbige Ausgaben für ls und grep
export LS_COLORS="di=1;34:ln=35:so=32:pi=33:ex=31:bd=34;46:cd=34;43:su=30;41:sg=30;46:tw=30;42:ow=30;43"
export GREP_OPTIONS="--color=auto"
' >> ~/.bashrcPassen Sie die Werte nach Bedarf an (z.B. den Wert für
EDITOR oder die Lokalisierung).
Jetzt ist es Zeit, alle Änderungen zu laden und zu testen:
source ~/.bashrcÜberprüfen Sie, ob alle Funktionen wie erwartet arbeiten: - Testen Sie Ihre Aliase und Funktionen - Überprüfen Sie, ob der Prompt wie gewünscht aussieht - Stellen Sie sicher, dass das Bin-Verzeichnis funktioniert
Erweitern Sie Ihre
.bash_aliases-Datei um mindestens fünf eigene
Aliase, die auf Ihre häufigsten Befehle zugeschnitten sind.
Erstellen Sie eine neue Shell-Funktion namens
weather, die das aktuelle Wetter für Ihren Standort anzeigt
(Tipp: Nutzen Sie curl mit einem Wetter-Dienst wie wttr.in:
curl wttr.in/Berlin).
Personalisieren Sie Ihren Prompt weiter, indem Sie eine Funktion hinzufügen, die die aktuelle Zeit anzeigt.
Erstellen Sie ein “Welcome”-Skript in Ihrem Bin-Verzeichnis, das beim Öffnen eines neuen Terminals automatisch ausgeführt wird und nützliche Systeminformationen anzeigt.
Richten Sie Tab-Vervollständigung für Ihre eigenen Skripte ein, indem Sie eine entsprechende Completion-Datei erstellen und einbinden.
Sie haben die Übung erfolgreich abgeschlossen, wenn Sie:
echo $? nach der Ausführung von
source ~/.bashrc, um zu überprüfen, ob es Fehler gab (0
bedeutet Erfolg).