Variablen zuweisen und neu zuweisen in Bash

ShellBeginner
Jetzt üben

Einführung

Dieses Tutorial führt Sie durch den Prozess des Zuweisens und Neuzuweisens von Variablen in Bash, der beliebten Shell-Skriptsprache. Variablen sind grundlegende Bausteine in Bash-Skripten, mit denen Sie Daten speichern und manipulieren können. In diesem praktischen Lab werden Sie lernen, wie man Variablen deklariert, ihnen Werte zuweist und sie in Befehlen und Skripten verwendet. Am Ende dieses Tutorials werden Sie ein solides Verständnis dafür haben, wie man effektiv mit Variablen in Bash arbeitet, so dass Sie leistungsfähigere und flexiblere Skripte schreiben können.

Erstellen und Zuweisen von Bash-Variablen

In Bash ermöglichen Variablen das Speichern von Daten, auf die später in Ihrem Skript zugegriffen und die geändert werden können. Beginnen wir mit dem Erstellen einer einfachen Variable und dem Zuweisen eines Werts dazu.

Öffnen Sie ein neues Terminal in der LabEx-Umgebung. Sie sollten sich im Verzeichnis /home/labex/project befinden.

Um einer Variable in Bash einen Wert zuzuweisen, verwenden Sie die folgende Syntax:

variable_name=value

Beachten Sie, dass sich keine Leerzeichen um das Gleichheitszeichen befinden dürfen.

Lassen Sie uns unsere erste Variable erstellen:

  1. Geben Sie im Terminal den folgenden Befehl ein und drücken Sie die Eingabetaste:
name="John"
  1. Um den Wert der Variable anzuzeigen, verwenden Sie den Befehl echo mit dem Variablennamen, dem ein Dollarzeichen ($) vorangestellt ist:
echo $name

Sie sollten die folgende Ausgabe sehen:

John
  1. Sie können auch doppelte Anführungszeichen um den Variablennamen verwenden:
echo "My name is $name"

Ausgabe:

My name is John
  1. Um derselben Variable einen neuen Wert zuzuweisen, verwenden Sie einfach erneut den Zuweisungsoperator (=):
name="Alice"
echo "My name is $name"

Ausgabe:

My name is Alice

Regeln für die Variablennamen

Beachten Sie beim Erstellen von Variablen in Bash die folgenden Namenskonventionen:

  • Variablennamen können Buchstaben, Zahlen und Unterstriche enthalten
  • Variablennamen müssen mit einem Buchstaben oder einem Unterstrich beginnen
  • Variablennamen sind case-sensitive (Groß- und Kleinschreibung wird beachtet)
  • In Variablennamen sind keine Leerzeichen erlaubt

Lassen Sie uns eine Datei erstellen, um mit Variablen zu üben. Erstellen Sie in der WebIDE eine neue Datei namens variables.sh im Projektverzeichnis:

  1. Klicken Sie in der IDE auf das Symbol "Neue Datei"
  2. Benennen Sie die Datei variables.sh
  3. Fügen Sie der Datei den folgenden Code hinzu:
#!/bin/bash

## Assigning variables
first_name="John"
last_name="Doe"
age=25

## Displaying variables
echo "First name: $first_name"
echo "Last name: $last_name"
echo "Age: $age"

## Reassigning variables
first_name="Jane"
echo "Updated first name: $first_name"
  1. Speichern Sie die Datei, indem Sie Strg+S drücken oder auf Datei → Speichern klicken

  2. Machen Sie das Skript ausführbar, indem Sie den folgenden Befehl im Terminal ausführen:

chmod +x variables.sh
  1. Führen Sie das Skript mit folgendem Befehl aus:
./variables.sh

Sie sollten die folgende Ausgabe sehen:

First name: John
Last name: Doe
Age: 25
Updated first name: Jane

Dies zeigt, wie man Variablen erstellt, ihnen Werte zuweist und neue Werte neu zuweist.

Arbeiten mit Variablenwerten und String-Operationen

In diesem Schritt werden wir verschiedene Möglichkeiten zur Arbeit mit Variablenwerten in Bash untersuchen, einschließlich String-Operationen und arithmetischen Berechnungen.

String-Operationen

Bash bietet verschiedene Möglichkeiten zur Manipulation von String-Werten, die in Variablen gespeichert sind.

  1. Erstellen Sie eine neue Datei namens string_operations.sh im Projektverzeichnis:
#!/bin/bash

## String concatenation
greeting="Hello"
name="World"
message="$greeting $name"
echo $message

## String length
text="Welcome to Bash scripting"
length=${#text}
echo "The length of '$text' is $length characters"

## Extracting substrings
substring=${text:0:7}
echo "Substring: $substring"

## Converting to uppercase and lowercase
uppercase=${text^^}
lowercase=${text,,}
echo "Uppercase: $uppercase"
echo "Lowercase: $lowercase"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x string_operations.sh
  1. Führen Sie das Skript aus:
./string_operations.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Hello World
The length of 'Welcome to Bash scripting' is 25 characters
Substring: Welcome
Uppercase: WELCOME TO BASH SCRIPTING
Lowercase: welcome to bash scripting

Arithmetische Operationen

Bash ermöglicht es Ihnen auch, arithmetische Operationen mit Variablen durchzuführen.

  1. Erstellen Sie eine neue Datei namens arithmetic_operations.sh im Projektverzeichnis:
#!/bin/bash

## Assigning numeric values
x=5
y=3

## Basic arithmetic operations
sum=$((x + y))
difference=$((x - y))
product=$((x * y))
quotient=$((x / y))
remainder=$((x % y))

## Display results
echo "x = $x, y = $y"
echo "Sum: $x + $y = $sum"
echo "Difference: $x - $y = $difference"
echo "Product: $x * $y = $product"
echo "Quotient: $x / $y = $quotient"
echo "Remainder: $x % $y = $remainder"

## Increment and decrement
echo "Initial value of x: $x"
x=$((x + 1))
echo "After increment: $x"
x=$((x - 1))
echo "After decrement: $x"

## Compound assignment operators
x+=5
echo "After x+=5: $x"
x-=2
echo "After x-=2: $x"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x arithmetic_operations.sh
  1. Führen Sie das Skript aus:
./arithmetic_operations.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

x = 5, y = 3
Sum: 5 + 3 = 8
Difference: 5 - 3 = 2
Product: 5 * 3 = 15
Quotient: 5 / 3 = 1
Remainder: 5 % 3 = 2
Initial value of x: 5
After increment: 6
After decrement: 5
After x+=5: 10
After x-=2: 8

Einlesen von Benutzereingaben in Variablen

Variablen können auch Eingaben speichern, die von Benutzern bereitgestellt werden. Erstellen wir ein Skript, das den Benutzer zur Eingabe auffordert:

  1. Erstellen Sie eine Datei namens user_input.sh:
#!/bin/bash

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

## Prompt the user for their age
echo "How old are you?"
read user_age

## Display the information
echo "Hello, $user_name! You are $user_age years old."

## Calculate birth year (approximate)
current_year=$(date +%Y)
birth_year=$((current_year - user_age))
echo "You were likely born in $birth_year."
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x user_input.sh
  1. Führen Sie das Skript aus:
./user_input.sh
  1. Geben Sie bei Aufforderung Ihren Namen und Ihr Alter ein. Das Skript zeigt eine Begrüßung an und berechnet Ihr ungefähres Geburtsjahr.

Dieser Schritt hat Ihnen gezeigt, wie Sie verschiedene Operationen mit Variablen durchführen können, einschließlich String-Manipulation, arithmetischen Berechnungen und dem Einlesen von Benutzereingaben.

Verwenden von Variablen in Skripten und Befehlen

In diesem Schritt werden wir untersuchen, wie man Variablen effektiv in Bash-Skripten und -Befehlen verwendet. Wir erstellen ein praktisches Skript, das die Variablennutzung in verschiedenen Szenarien demonstriert.

Erstellen eines einfachen Skripts mit Variablen

Erstellen wir ein Skript, das die Gesamtkosten von Artikeln in einem Warenkorb berechnet:

  1. Erstellen Sie eine neue Datei namens shopping_cart.sh im Projektverzeichnis:
#!/bin/bash

## Initialize variables for items and their prices
item1="Laptop"
price1=999
item2="Headphones"
price2=149
item3="Mouse"
price3=25

## Calculate the total price
total=$((price1 + price2 + price3))

## Display the shopping cart
echo "Shopping Cart:"
echo "-------------"
echo "$item1: \$$price1"
echo "$item2: \$$price2"
echo "$item3: \$$price3"
echo "-------------"
echo "Total: \$$total"

## Apply a discount if the total is over $1000
discount_threshold=1000
discount_rate=10

if [ $total -gt $discount_threshold ]; then
  discount_amount=$((total * discount_rate / 100))
  discounted_total=$((total - discount_amount))
  echo "Discount (${discount_rate}%): -\$$discount_amount"
  echo "Final Total: \$$discounted_total"
fi
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x shopping_cart.sh
  1. Führen Sie das Skript aus:
./shopping_cart.sh

Sie sollten die folgende Ausgabe sehen:

Shopping Cart:
-------------
Laptop: $999
Headphones: $149
Mouse: $25
-------------
Total: $1173
Discount (10%): -$117
Final Total: $1056

Verwenden von Variablen mit Command Substitution

Mit der Command Substitution (Befehlssubstitution) können Sie die Ausgabe eines Befehls erfassen und in einer Variable speichern. Erstellen wir ein Skript, das dies demonstriert:

  1. Erstellen Sie eine neue Datei namens system_info.sh:
#!/bin/bash

## Get current date and time
current_date=$(date +"%Y-%m-%d")
current_time=$(date +"%H:%M:%S")

## Get system information
hostname=$(hostname)
os_type=$(uname -s)
kernel_version=$(uname -r)
uptime_info=$(uptime -p)
memory_free=$(free -h | awk '/^Mem:/ {print $4}')
disk_free=$(df -h / | awk 'NR==2 {print $4}')

## Display the information
echo "System Information Report"
echo "========================="
echo "Date: $current_date"
echo "Time: $current_time"
echo "Hostname: $hostname"
echo "OS Type: $os_type"
echo "Kernel Version: $kernel_version"
echo "Uptime: $uptime_info"
echo "Free Memory: $memory_free"
echo "Free Disk Space: $disk_free"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x system_info.sh
  1. Führen Sie das Skript aus:
./system_info.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen (mit Werten, die für Ihr System spezifisch sind):

System Information Report
=========================
Date: 2023-11-20
Time: 14:30:25
Hostname: labex
OS Type: Linux
Kernel Version: 5.15.0-1015-aws
Uptime: up 2 hours, 15 minutes
Free Memory: 1.2Gi
Free Disk Space: 15G

Verwenden von Variablen in Schleifen

Variablen sind besonders nützlich in Schleifen. Erstellen wir ein Skript, das dies demonstriert:

  1. Erstellen Sie eine neue Datei namens countdown.sh:
#!/bin/bash

## Get countdown start value from user
echo "Enter a number to start countdown:"
read count

## Validate that input is a number
if [[ ! $count =~ ^[0-9]+$ ]]; then
  echo "Error: Please enter a valid number"
  exit 1
fi

## Perform countdown
echo "Starting countdown from $count:"
while [ $count -gt 0 ]; do
  echo $count
  count=$((count - 1))
  sleep 1
done

echo "Blast off!"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x countdown.sh
  1. Führen Sie das Skript aus:
./countdown.sh
  1. Geben Sie bei Aufforderung eine kleine Zahl (z. B. 5) ein.

Das Skript zählt von der eingegebenen Zahl herunter, gibt jede Zahl aus und am Ende "Blast off!" aus.

Diese Beispiele zeigen, wie Variablen in verschiedenen Kontexten innerhalb von Bash-Skripten verwendet werden können, wodurch diese dynamischer und flexibler werden.

Variablen-Scope und spezielle Variablen

In diesem letzten Schritt werden wir den Variablen-Scope in Bash untersuchen und mehr über spezielle Variablen erfahren, die Bash bereitstellt.

Verstehen des Variablen-Scope

In Bash können Variablen unterschiedliche Scopes haben, die bestimmen, wo sie zugänglich sind:

  1. Globale Variablen: Diese sind im gesamten Skript zugänglich.
  2. Lokale Variablen: Diese sind nur innerhalb einer bestimmten Funktion oder eines Blocks zugänglich.

Erstellen wir ein Skript, um den Variablen-Scope zu demonstrieren:

  1. Erstellen Sie eine neue Datei namens variable_scope.sh:
#!/bin/bash

## Global variable
global_var="I am a global variable"

## Function that demonstrates variable scope
demo_scope() {
  ## Local variable
  local local_var="I am a local variable"

  ## Access global variable
  echo "Inside function: global_var = $global_var"

  ## Access local variable
  echo "Inside function: local_var = $local_var"

  ## Modify global variable
  global_var="Global variable modified"
}

## Main script
echo "Before function call: global_var = $global_var"

## This will fail because local_var doesn't exist yet
echo "Before function call: local_var = $local_var"

## Call the function
demo_scope

## After function call
echo "After function call: global_var = $global_var"

## This will fail because local_var is only accessible within the function
echo "After function call: local_var = $local_var"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x variable_scope.sh
  1. Führen Sie das Skript aus:
./variable_scope.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Before function call: global_var = I am a global variable
Before function call: local_var =
Inside function: global_var = I am a global variable
Inside function: local_var = I am a local variable
After function call: global_var = Global variable modified
After function call: local_var =

Beachten Sie, dass:

  • Die globale Variable global_var sowohl innerhalb als auch außerhalb der Funktion zugänglich ist.
  • Die lokale Variable local_var nur innerhalb der Funktion zugänglich ist.
  • Änderungen an der globalen Variable nach dem Ende der Funktion bestehen bleiben.

Arbeiten mit speziellen Variablen

Bash stellt mehrere spezielle Variablen bereit, die spezifische Informationen enthalten. Untersuchen wir einige davon:

  1. Erstellen Sie eine neue Datei namens special_variables.sh:
#!/bin/bash

## Special variables demonstration
echo "Script name: $0"
echo "Process ID: $$"
echo "Number of arguments: $#"
echo "All arguments: $@"
echo "Exit status of last command: $?"
echo "Current user: $USER"
echo "Current hostname: $HOSTNAME"
echo "Random number: $RANDOM"

## Function to demonstrate positional parameters
show_params() {
  echo "Function received $## parameters"
  echo "Parameter 1: $1"
  echo "Parameter 2: $2"
  echo "Parameter 3: $3"
}

## Call the function with parameters
echo -e "\nCalling function with parameters:"
show_params apple banana cherry

## Demonstrate positional parameters to the script
echo -e "\nScript positional parameters:"
echo "Parameter 1: $1"
echo "Parameter 2: $2"
echo "Parameter 3: $3"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x special_variables.sh
  1. Führen Sie das Skript mit einigen Argumenten aus:
./special_variables.sh arg1 arg2 arg3

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Script name: ./special_variables.sh
Process ID: 12345
Number of arguments: 3
All arguments: arg1 arg2 arg3
Exit status of last command: 0
Current user: labex
Current hostname: labex
Random number: 23456

Calling function with parameters:
Function received 3 parameters
Parameter 1: apple
Parameter 2: banana
Parameter 3: cherry

Script positional parameters:
Parameter 1: arg1
Parameter 2: arg2
Parameter 3: arg3

Umgebungsvariablen

Umgebungsvariablen sind spezielle Variablen, die das Verhalten der Shell und von Programmen beeinflussen. Erstellen wir ein Skript, um diese zu untersuchen:

  1. Erstellen Sie eine neue Datei namens environment_variables.sh:
#!/bin/bash

## Display common environment variables
echo "HOME directory: $HOME"
echo "Current user: $USER"
echo "Shell: $SHELL"
echo "Path: $PATH"
echo "Current working directory: $PWD"
echo "Terminal: $TERM"
echo "Language: $LANG"

## Creating and exporting a new environment variable
echo -e "\nCreating a new environment variable:"
MY_VAR="Hello from environment variable"
export MY_VAR
echo "MY_VAR = $MY_VAR"

## Demonstrate that child processes inherit environment variables
echo -e "\nAccessing environment variable from a child process:"
bash -c 'echo "Child process sees MY_VAR = $MY_VAR"'

## Remove the environment variable
echo -e "\nRemoving the environment variable:"
unset MY_VAR
echo "MY_VAR = $MY_VAR (should be empty)"
  1. Speichern Sie die Datei und machen Sie sie ausführbar:
chmod +x environment_variables.sh
  1. Führen Sie das Skript aus:
./environment_variables.sh

Sie sollten eine Ausgabe sehen, die verschiedene Umgebungsvariablen zeigt und demonstriert, wie diese erstellt, aufgerufen und entfernt werden können.

Dieser Schritt hat Ihnen gezeigt, wie der Variablen-Scope in Bash funktioniert, und Sie mit speziellen Variablen vertraut gemacht, die nützliche Informationen innerhalb Ihrer Skripte bereitstellen.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Arbeit mit Variablen in Bash-Skripten gelernt. Sie haben praktische Erfahrung gesammelt mit:

  • Erstellen und Zuweisen von Werten zu Variablen
  • Arbeiten mit String-Operationen und arithmetischen Berechnungen
  • Verwenden von Variablen in Skripten und Befehlen
  • Verstehen des Variablen-Scope und Arbeiten mit speziellen Variablen

Diese Fähigkeiten bilden die Grundlage des Bash-Scriptings und ermöglichen es Ihnen, anspruchsvollere und leistungsfähigere Skripte zu schreiben. Variablen sind ein wesentliches Werkzeug, um Ihre Skripte dynamisch und wiederverwendbar zu machen, sodass sie sich an verschiedene Eingaben und Szenarien anpassen können.

Denken Sie bei der Fortsetzung Ihrer Reise im Bash-Scripting an diese wichtigen Punkte:

  • Wählen Sie immer beschreibende Variablennamen.
  • Achten Sie beim Schreiben von Funktionen auf den Variablen-Scope.
  • Verwenden Sie spezielle Variablen, um auf nützliche Informationen innerhalb Ihrer Skripte zuzugreifen.
  • Nutzen Sie Umgebungsvariablen für Konfiguration und Anpassung.

Mit diesen Fähigkeiten sind Sie nun bestens gerüstet, um komplexere Bash-Skripte zur Automatisierung von Aufgaben und zur Verwaltung Ihres Systems zu erstellen.