Wie man den Wert einer Variable in einem Shell-Skript ausgibt

Einführung

Shell-Scripting ist ein mächtiges Werkzeug zur Automatisierung von Aufgaben in Linux-Umgebungen. Eine der grundlegenden Fähigkeiten in der Shell-Programmierung ist der Umgang mit Variablen – temporären Speicherorten, die Daten enthalten. Dieses Tutorial führt Sie durch den Prozess der Erstellung von Variablen und der Ausgabe ihrer Werte in Shell-Skripten. Am Ende dieses Labors werden Sie verstehen, wie man Variablen deklariert, auf ihre Werte zugreift und sie in praktische Shell-Skripte einbaut.

Erstellen Ihres ersten Shell-Skripts mit Variablen

Beginnen wir mit der Erstellung eines einfachen Shell-Skripts, das demonstriert, wie man Variablen deklariert und verwendet.

Was sind Shell-Variablen?

Shell-Variablen sind benannte Speicherorte, die Werte in Shell-Skripten enthalten können. Sie ermöglichen es Ihnen, Daten wie Textstrings, Zahlen, Dateipfade und Befehlsausgaben zu speichern und abzurufen. Variablen machen Ihre Skripte flexibler und wiederverwendbarer.

Erstellen Ihres ersten Skripts

Lassen Sie uns eine Shell-Skriptdatei erstellen:

1. Öffnen Sie das WebIDE-Terminal
2. Navigieren Sie zum Projektverzeichnis (falls Sie sich noch nicht dort befinden):

   cd ~/project

3. Erstellen Sie eine neue Datei namens myscript.sh mit dem WebIDE-Editor:
   • Klicken Sie auf das Symbol "Neue Datei" in der WebIDE
   • Nennen Sie sie myscript.sh
   • Fügen Sie der Datei den folgenden Inhalt hinzu:

#!/bin/bash

## This is my first shell script with variables

## Declaring a variable
name="LabEx User"

## Printing the variable
echo "Hello, $name!"

## Printing the current date using a variable
current_date=$(date)
echo "Today is: $current_date"

4. Speichern Sie die Datei, indem Sie Strg+S drücken oder Datei > Speichern auswählen

5. Machen Sie das Skript mit dem folgenden Befehl ausführbar:

   chmod +x myscript.sh

6. Führen Sie Ihr Skript aus:

   ./myscript.sh

Sie sollten eine Ausgabe ähnlich dieser sehen:

Hello, LabEx User!
Today is: Thu Jul 13 10:30:45 UTC 2023

Das Skript verstehen

Lassen Sie uns aufschlüsseln, was in unserem Skript passiert ist:

1. Die erste Zeile #!/bin/bash (genannt Shebang) weist das System an, die Bash-Shell zur Ausführung des Skripts zu verwenden.
2. Wir haben eine Variable namens name erstellt und ihr den Wert "LabEx User" mit name="LabEx User" zugewiesen.
3. Wir haben den Wert der Variable mit echo "Hello, $name!" ausgegeben. Das $-Symbol vor dem Variablennamen weist die Shell an, den Wert der Variable zu ersetzen.
4. Wir haben eine weitere Variable current_date erstellt und ihr die Ausgabe des Befehls date mit $(date) zugewiesen.
5. Wir haben den Wert der Variable current_date ausgegeben.

Regeln für die Variablennamen

Beachten Sie beim Erstellen von Variablen in Shell-Skripten die folgenden Namenskonventionen:

• Variablennamen können Buchstaben, Zahlen und Unterstriche enthalten
• Sie müssen mit einem Buchstaben oder einem Unterstrich beginnen
• Um das Gleichheitszeichen herum sind keine Leerzeichen erlaubt, wenn Werte zugewiesen werden
• Variablennamen sind case-sensitive (Groß-/Kleinschreibung beachten) (NAME, name und Name sind drei verschiedene Variablen)

Versuchen Sie, das Skript zu ändern, um Ihre eigenen Variablen einzufügen, und führen Sie es erneut aus, um die Ergebnisse zu sehen.

Verschiedene Möglichkeiten, Variablenwerte auszugeben

Nachdem Sie die Grundlagen der Erstellung von Variablen verstanden haben, wollen wir verschiedene Methoden zur Ausgabe ihrer Werte in Shell-Skripten untersuchen.

Verwendung von doppelten Anführungszeichen

Die gebräuchlichste Methode zur Ausgabe von Variablen ist die Verwendung von doppelten Anführungszeichen mit dem Befehl echo. Doppelte Anführungszeichen ermöglichen es der Shell, Variablennamen zu interpretieren und ihre Werte zu ersetzen.

Erstellen Sie eine neue Datei namens print_variables.sh:

1. Klicken Sie auf das Symbol "Neue Datei" in der WebIDE
2. Nennen Sie sie print_variables.sh
3. Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Declaring variables
name="LabEx"
version=1.0
is_active=true

## Printing variables with double quotes
echo "Application name: $name"
echo "Version: $version"
echo "Active status: $is_active"

## Printing multiple variables in one statement
echo "The $name application version $version is $is_active"

4. Speichern Sie die Datei (Strg+S oder Datei > Speichern)
5. Machen Sie sie ausführbar:

   chmod +x print_variables.sh

6. Führen Sie das Skript aus:

   ./print_variables.sh

Sie sollten eine Ausgabe ähnlich dieser sehen:

Application name: LabEx
Version: 1.0
Active status: true
The LabEx application version 1.0 is true

Verwendung von geschweiften Klammern

Manchmal müssen Sie genauer sein, wo ein Variablenname beginnt und endet. Geschweifte Klammern helfen dabei, indem sie den Variablennamen klar abgrenzen.

Fügen Sie Ihrem Skript print_variables.sh die folgenden Zeilen hinzu:

## Using curly braces to clearly define variable boundaries
app="${name}App"
echo "Application full name: $app"

## This avoids confusion when you want to append text directly to a variable's value
echo "Application name with text: ${name}Text"

Speichern und führen Sie das Skript erneut aus:

./print_variables.sh

Die zusätzliche Ausgabe sollte Folgendes zeigen:

Application full name: LabExApp
Application name with text: LabExText

Verwendung von einfachen Anführungszeichen

Im Gegensatz zu doppelten Anführungszeichen verhindern einfache Anführungszeichen die Variablensubstitution und geben den wörtlichen Text aus.

Fügen Sie diese Zeilen zu Ihrem Skript hinzu:

## Using single quotes (no variable substitution)
echo 'With single quotes: $name is not replaced'

## Mixing quote types for complex output
echo "This is the variable value: '$name'"

Speichern und führen Sie das Skript erneut aus. Sie sollten Folgendes sehen:

With single quotes: $name is not replaced
This is the variable value: 'LabEx'

Verwendung von printf für formatierte Ausgabe

Der Befehl printf bietet mehr Kontrolle über die Formatierung Ihrer Ausgabe:

## Using printf for formatted output
printf "Name: %s\nVersion: %.1f\n" "$name" "$version"

## Formatting numbers with printf
number=42.5678
printf "Formatted number: %.2f\n" $number

Speichern und führen Sie das Skript erneut aus. Die zusätzliche Ausgabe zeigt:

Name: LabEx
Version: 1.0
Formatted number: 42.57

Experimentieren Sie mit den verschiedenen Ausgabemethoden, um herauszufinden, welche für Ihre Bedürfnisse am besten geeignet sind.

Erstellen eines praktischen Shell-Skripts mit Benutzereingabe

Lassen Sie uns nun ein praktischeres Shell-Skript erstellen, das Benutzereingaben entgegennimmt, in Variablen speichert und die Ergebnisse anzeigt.

Lesen der Benutzereingabe

Der Befehl read ermöglicht es Ihrem Skript, Eingaben von Benutzern zu akzeptieren. Erstellen wir ein einfaches Begrüßungsskript:

1. Erstellen Sie eine neue Datei namens greeting.sh:
   • Klicken Sie auf das Symbol "Neue Datei" in der WebIDE
   • Nennen Sie sie greeting.sh
   • Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Simple greeting script that takes user input

## Prompt the user for their name
echo "What is your name?"
read username

## Prompt for age
echo "How old are you?"
read age

## Display a greeting with the provided information
echo "Hello, $username! You are $age years old."

## Calculate birth year (approximately)
current_year=$(date +%Y)
birth_year=$((current_year - age))

echo "You were born around the year $birth_year."

## Adding a personalized message based on age
if [ $age -lt 18 ]; then
  echo "You are a minor."
elif [ $age -ge 18 ] && [ $age -lt 65 ]; then
  echo "You are an adult."
else
  echo "You are a senior."
fi

2. Speichern Sie die Datei (Strg+S oder Datei > Speichern)

3. Machen Sie sie ausführbar:

   chmod +x greeting.sh

4. Führen Sie das Skript aus:

   ./greeting.sh

5. Geben Sie bei Aufforderung Ihren Namen und Ihr Alter ein. Sie sollten eine personalisierte Ausgabe basierend auf Ihrer Eingabe sehen.

Die Skriptkomponenten verstehen

Lassen Sie uns die wichtigsten Teile dieses Skripts aufschlüsseln:

1. Der Befehl read speichert die Benutzereingabe in Variablen (username und age).
2. Wir verwenden die Variablen in echo-Anweisungen, um eine personalisierte Ausgabe zu erstellen.
3. Wir führen Arithmetik mit der Syntax $((expression)) durch, um das Geburtsjahr zu berechnen.
4. Wir verwenden bedingte Anweisungen (if, elif, else), um je nach Alterswert unterschiedliche Nachrichten bereitzustellen.
5. Wir verwenden den Befehl date mit Formatierungsoptionen, um das aktuelle Jahr zu erhalten.

Das Skript interaktiver gestalten

Lassen Sie uns unser Skript erweitern, um es interaktiver und nützlicher zu machen. Fügen Sie Ihrer Datei greeting.sh Folgendes hinzu:

## Ask if the user wants to see the current system information
echo "Would you like to see some system information? (yes/no)"
read response

## Convert the response to lowercase for easier comparison
response_lower=$(echo "$response" | tr '[:upper:]' '[:lower:]')

if [ "$response_lower" = "yes" ] || [ "$response_lower" = "y" ]; then
  echo "System information for user $username:"
  echo "-------------------------------------"
  echo "Hostname: $(hostname)"
  echo "Kernel version: $(uname -r)"
  echo "System uptime: $(uptime -p)"
  echo "CPU information: $(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')"
  echo "Memory available: $(free -h | grep Mem | awk '{print $7}')"
  echo "-------------------------------------"
else
  echo "No problem, $username. Have a great day!"
fi

Speichern Sie die Datei und führen Sie sie erneut aus:

./greeting.sh

Befolgen Sie die Aufforderungen und geben Sie "yes" ein, wenn Sie gefragt werden, ob Sie Systeminformationen sehen möchten. Sie sollten detaillierte Informationen über das System sehen.

Dieses Skript demonstriert, wie man:

• Benutzereingaben liest und verarbeitet
• Variablen speichert und manipuliert
• Berechnungen durchführt
• Entscheidungen basierend auf Variablenwerten trifft
• Systembefehle ausführt und deren Ausgaben in Variablen speichert
• Formatierte Ausgabe für den Benutzer anzeigt

Versuchen Sie, das Skript zu ändern, um weitere interaktive Funktionen oder verschiedene Arten von Systeminformationen hinzuzufügen.

Erstellen eines Shell-Skripts für Dateioperationen

Wenden wir unser Wissen über Shell-Variablen an, um ein nützliches Skript zu erstellen, das Dateioperationen durchführt. Dieses Skript zeigt, wie Variablen bei der Automatisierung von Dateiverwaltungsaufgaben helfen können.

Erstellen eines Backup-Skripts

Erstellen wir ein Skript, das eine Sicherungskopie von Dateien in einem angegebenen Verzeichnis erstellt:

1. Erstellen wir zunächst ein Testverzeichnis und einige Beispieldateien, mit denen wir arbeiten können:

   mkdir -p ~/project/test_files
   echo "This is file 1" > ~/project/test_files/file1.txt
   echo "This is file 2" > ~/project/test_files/file2.txt
   echo "This is file 3" > ~/project/test_files/file3.txt

2. Erstellen Sie nun eine neue Datei namens backup.sh:

   • Klicken Sie auf das Symbol "Neue Datei" in der WebIDE
   • Nennen Sie sie backup.sh
   • Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## A script to backup files from a source directory to a backup directory

## Define variables for directories
source_dir="$HOME/project/test_files"
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Print the script's purpose
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"

## Create the backup directory if it doesn't exist
if [ ! -d "$backup_dir" ]; then
  echo "Creating backup directory: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Create a timestamped backup directory
mkdir -p "$backup_dir/$backup_name"

## Check if source directory exists
if [ ! -d "$source_dir" ]; then
  echo "Error: Source directory $source_dir does not exist!"
  exit 1
fi

## Count the number of files in the source directory
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."

## Copy the files to the backup directory
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verify the copy operation
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."

## Check if all files were copied successfully
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup completed successfully!"
else
  echo "Warning: Not all files were copied. Please check for errors."
fi

## List the contents of the backup directory
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"

## Display the total size of the backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"

3. Speichern Sie die Datei (Strg+S oder Datei > Speichern)
4. Machen Sie sie ausführbar:

   chmod +x backup.sh

5. Führen Sie das Skript aus:

   ./backup.sh

Sie sollten eine Ausgabe sehen, die den Sicherungsprozess zeigt, einschließlich:

• Der Quell- und Sicherungsverzeichnisse
• Die Anzahl der gefundenen Dateien
• Bestätigung des Kopiervorgangs
• Der Inhalt des Sicherungsverzeichnisses
• Die Gesamtgröße der Sicherung

Das Skript verstehen

Dieses Backup-Skript demonstriert mehrere wichtige Konzepte:

1. Variablenverwendung: Wir verwenden Variablen, um Verzeichnispfade, Datumsstempel und Zählungen zu speichern
2. Kommandoersetzung (Command substitution): Wir verwenden die Syntax $(command), um die Ausgabe von Befehlen in Variablen zu erfassen
3. Bedingte Anweisungen (Conditional statements): Wir verwenden if-Anweisungen, um zu überprüfen, ob Verzeichnisse existieren
4. Zeichenkettenmanipulation (String manipulation): Wir erstellen einen eindeutigen Sicherungsnamen mithilfe des Datumsstempels
5. Pfadvariablen (Path variables): Wir verwenden $HOME, um auf das Home-Verzeichnis des Benutzers zu verweisen
6. Befehlsausführung (Command execution): Wir verwenden Shell-Befehle wie mkdir, cp und ls innerhalb unseres Skripts
7. Exit-Codes: Wir verwenden exit 1, um das Skript mit einem Fehlerstatus zu beenden

Erweitern des Backup-Skripts

Ändern wir unser Skript, um ein benutzerdefiniertes Quellverzeichnis vom Benutzer zu akzeptieren:

1. Öffnen Sie backup.sh im Editor
2. Ersetzen Sie den Inhalt durch Folgendes:

#!/bin/bash

## A script to backup files from a source directory to a backup directory

## Check if a source directory was provided
if [ $## -eq 0 ]; then
  ## No argument provided, use default directory
  source_dir="$HOME/project/test_files"
  echo "No source directory specified, using default: $source_dir"
else
  ## Use the provided directory
  source_dir="$1"
  echo "Using specified source directory: $source_dir"
fi

## Define variables for directories
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Print the script's purpose
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"

## Create the backup directory if it doesn't exist
if [ ! -d "$backup_dir" ]; then
  echo "Creating backup directory: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Create a timestamped backup directory
mkdir -p "$backup_dir/$backup_name"

## Check if source directory exists
if [ ! -d "$source_dir" ]; then
  echo "Error: Source directory $source_dir does not exist!"
  exit 1
fi

## Count the number of files in the source directory
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."

## Copy the files to the backup directory
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verify the copy operation
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."

## Check if all files were copied successfully
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup completed successfully!"
else
  echo "Warning: Not all files were copied. Please check for errors."
fi

## List the contents of the backup directory
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"

## Display the total size of the backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"

3. Speichern Sie die Datei
4. Führen Sie das Skript mit einem benutzerdefinierten Verzeichnis aus:

   ./backup.sh ~/project

Das erweiterte Skript demonstriert nun:

• Kommandozeilenargumente mit $1 (dem ersten Argument, das an das Skript übergeben wird)
• Standardwerte, wenn keine Argumente angegeben werden
• Parameterprüfung mit $# (der Anzahl der Argumente)

Dieses Backup-Skript ist ein praktisches Beispiel dafür, wie Shell-Variablen verwendet werden können, um nützliche, flexible Werkzeuge zur Automatisierung von Dateiverwaltungsaufgaben zu erstellen.

Zusammenfassung

In diesem Lab haben Sie die wesentlichen Fähigkeiten für die Arbeit mit Variablen in Shell-Skripten gelernt:

• Erstellen und Deklarieren von Shell-Variablen
• Verschiedene Möglichkeiten, Variablenwerte mit echo, printf und Anführungszeichen auszugeben
• Lesen und Verarbeiten von Benutzereingaben
• Durchführen von Berechnungen mit Shell-Variablen
• Verwenden von Variablen für Dateioperationen und Sicherungsaufgaben
• Behandeln von Kommandozeilenargumenten

Diese Fähigkeiten bilden eine solide Grundlage für Shell-Skripte und ermöglichen es Ihnen, dynamischere und flexiblere Skripte zur Automatisierung verschiedener Aufgaben in einer Linux-Umgebung zu erstellen. Wenn Sie Ihre Shell-Skripting-Reise fortsetzen, können Sie auf diesen Konzepten aufbauen, um komplexere Skripte für Systemadministration, Dateiverwaltung und Datenverarbeitungsaufgaben zu entwickeln.