Wie man Bash-Array-Elemente zeilenweise ausgibt

Einführung

In diesem Tutorial werden wir Bash-Arrays (Bash-Arrays) untersuchen und lernen, wie man jedes Element in einer neuen Zeile ausgibt - eine häufige Anforderung in der Shell-Skripting. Bash-Arrays ermöglichen es Ihnen, mehrere Werte in einer einzigen Variablen zu speichern, was sie für die Organisation von Daten in Ihren Skripten unerlässlich macht.

Am Ende dieses Labs (Labor) werden Sie verstehen, wie man Arrays erstellt, Array-Elemente manipuliert und verschiedene Techniken verwendet, um den Inhalt eines Arrays Zeile für Zeile auszugeben. Diese Fähigkeiten werden Ihnen helfen, effizientere und lesbarere Shell-Skripte für Aufgaben wie die Verarbeitung von Dateilisten, die Verarbeitung von Befehlsausgaben und die Automatisierung von Systemadministrationstasks zu schreiben.

Skills Graph

Erstellen und Verstehen von Bash-Arrays

Bash-Arrays ermöglichen es Ihnen, mehrere Werte in einer einzigen Variablen zu speichern. Lassen Sie uns lernen, wie man sie erstellt und damit arbeitet.

Erstellen Ihres ersten Arrays

Öffnen Sie ein Terminal in der WebIDE. Standardmäßig sollten Sie sich im Verzeichnis /home/labex/project befinden. Beginnen wir damit, ein einfaches Bash-Skript zu erstellen:

1. Erstellen Sie in der WebIDE eine neue Datei namens array_demo.sh, indem Sie auf das Symbol "Neue Datei" im Explorer-Bereich klicken oder die Menüoption "Datei > Neue Datei" verwenden.

2. Fügen Sie der Datei den folgenden Inhalt hinzu:

#!/bin/bash

## Create an array of fruits
fruits=("apple" "banana" "orange" "grape" "kiwi")

## Print the entire array
echo "All fruits: ${fruits[@]}"

## Print the first element (index 0)
echo "First fruit: ${fruits[0]}"

## Print the third element (index 2)
echo "Third fruit: ${fruits[2]}"

## Print the number of elements in the array
echo "Number of fruits: ${#fruits[@]}"

3. Speichern Sie die Datei, indem Sie Strg+S drücken oder die Menüoption "Datei > Speichern" verwenden.

4. Machen Sie nun das Skript ausführbar, indem Sie diesen Befehl im Terminal ausführen:

chmod +x /home/labex/project/array_demo.sh

5. Führen Sie das Skript aus:

./array_demo.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

All fruits: apple banana orange grape kiwi
First fruit: apple
Third fruit: orange
Number of fruits: 5

Verstehen der Array-Syntax

Lassen Sie uns die Array-Syntax analysieren:

• Erstellen eines Arrays: fruits=("apple" "banana" "orange" "grape" "kiwi")
  Dies erstellt ein Array namens fruits mit fünf Elementen.

• Zugriff auf alle Elemente: ${fruits[@]}
  Das Symbol @ bezieht sich auf alle Elemente des Arrays.

• Zugriff auf ein bestimmtes Element: ${fruits[0]}, ${fruits[2]}
  Arrays in Bash sind nullbasiert indiziert, was bedeutet, dass das erste Element den Index 0 hat.

• Ermitteln der Array-Länge: ${#fruits[@]}
  Das Symbol # vor der Array-Referenz gibt die Anzahl der Elemente zurück.

Verschiedene Methoden zum Erstellen von Arrays

Lassen Sie uns ein neues Skript erstellen, um verschiedene Methoden zum Erstellen von Arrays zu demonstrieren:

1. Erstellen Sie eine neue Datei namens array_creation.sh:

#!/bin/bash

## Method 1: Direct declaration
colors=("red" "green" "blue" "yellow")
echo "Colors array: ${colors[@]}"

## Method 2: Individual element assignment
shapes=()
shapes[0]="circle"
shapes[1]="square"
shapes[2]="triangle"
echo "Shapes array: ${shapes[@]}"

## Method 3: Create array from command output
files=($(ls /home/labex/project))
echo "Files in current directory: ${files[@]}"

## Method 4: Create array from a string
data="one two three four"
numbers=($data)
echo "Numbers array: ${numbers[@]}"

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/array_creation.sh

3. Führen Sie das Skript aus:

./array_creation.sh

Sie sollten eine Ausgabe sehen, die alle verschiedenen Arrays zeigt, die Sie erstellt haben. Die genaue Ausgabe für das Dateien-Array hängt davon ab, welche Dateien in Ihrem Verzeichnis vorhanden sind.

Diese Beispiele demonstrieren die Flexibilität von Bash-Arrays und wie Sie sie je nach Bedarf auf verschiedene Weise erstellen können.

Manipulation von Array-Elementen

Nachdem wir nun wissen, wie man Arrays erstellt, lernen wir, wie man sie durch Hinzufügen, Entfernen und Ändern von Elementen manipuliert.

Ändern von Array-Elementen

Erstellen wir ein neues Skript, um die Manipulation von Arrays zu demonstrieren:

1. Erstellen Sie in der WebIDE eine neue Datei namens array_manipulation.sh:

#!/bin/bash

## Create an initial array
fruits=("apple" "banana" "orange")
echo "Initial array: ${fruits[@]}"

## Add an element to the end of the array
fruits+=("grape")
echo "After adding grape: ${fruits[@]}"

## Add multiple elements
fruits+=("kiwi" "mango")
echo "After adding kiwi and mango: ${fruits[@]}"

## Change an element
fruits[1]="blueberry"
echo "After changing banana to blueberry: ${fruits[@]}"

## Remove an element (this leaves an empty slot)
unset fruits[2]
echo "After removing the third element: ${fruits[@]}"

## Print array indices
echo "Array indices: ${!fruits[@]}"

## Recreate array to remove empty slots
new_fruits=()
for fruit in "${fruits[@]}"; do
  if [[ -n "$fruit" ]]; then
    new_fruits+=("$fruit")
  fi
done

fruits=("${new_fruits[@]}")
echo "After removing empty slots: ${fruits[@]}"

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/array_manipulation.sh

3. Führen Sie das Skript aus:

./array_manipulation.sh

Die Ausgabe sollte zeigen, wie sich das Array bei jeder Operation ändert:

Initial array: apple banana orange
After adding grape: apple banana orange grape
After adding kiwi and mango: apple banana orange grape kiwi mango
After changing banana to blueberry: apple blueberry orange grape kiwi mango
After removing the third element: apple blueberry  grape kiwi mango
Array indices: 0 1 3 4 5
After removing empty slots: apple blueberry grape kiwi mango

Slicing von Arrays

Untersuchen wir, wie man Teile eines Arrays extrahiert:

1. Erstellen Sie eine neue Datei namens array_slicing.sh:

#!/bin/bash

## Create a sample array
colors=("red" "orange" "yellow" "green" "blue" "indigo" "violet")
echo "Full array: ${colors[@]}"

## Extract a sub-array (starting index and length)
## Syntax: ${array[@]:start:length}
sub_array1=("${colors[@]:1:3}")
echo "Sub-array (indices 1-3): ${sub_array1[@]}"

## Extract from an index to the end
sub_array2=("${colors[@]:4}")
echo "Sub-array (from index 4 to end): ${sub_array2[@]}"

## Extract the last two elements
sub_array3=("${colors[@]: -2}") ## Note the space before -2
echo "Last two elements: ${sub_array3[@]}"

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/array_slicing.sh

3. Führen Sie das Skript aus:

./array_slicing.sh

Die Ausgabe wird verschiedene Methoden zum Slicing von Arrays demonstrieren:

Full array: red orange yellow green blue indigo violet
Sub-array (indices 1-3): orange yellow green
Sub-array (from index 4 to end): blue indigo violet
Last two elements: indigo violet

Suchen von Elementen in Arrays

Erstellen wir ein Skript, um zu zeigen, wie man Elemente in einem Array sucht:

1. Erstellen Sie eine neue Datei namens array_searching.sh:

#!/bin/bash

## Create a sample array
fruits=("apple" "banana" "orange" "grape" "kiwi")
echo "Our fruits: ${fruits[@]}"

## Function to search for an element in an array
search_array() {
  local needle="$1"
  shift
  local haystack=("$@")

  for i in "${!haystack[@]}"; do
    if [[ "${haystack[$i]}" == "$needle" ]]; then
      echo "Found '$needle' at index $i"
      return 0
    fi
  done

  echo "'$needle' not found in the array"
  return 1
}

## Search for some fruits
search_array "orange" "${fruits[@]}"
search_array "banana" "${fruits[@]}"
search_array "watermelon" "${fruits[@]}"

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/array_searching.sh

3. Führen Sie das Skript aus:

./array_searching.sh

Die Ausgabe wird die Ergebnisse der Suche nach verschiedenen Elementen zeigen:

Our fruits: apple banana orange grape kiwi
Found 'orange' at index 2
Found 'banana' at index 1
'watermelon' not found in the array

Diese Beispiele demonstrieren die gängigen Operationen, die Sie an Bash-Arrays ausführen können, was essentielle Fähigkeiten für die Arbeit mit Datensammlungen in Ihren Skripten ist.

Ausgabe von Array-Elementen Zeilenweise

In diesem Schritt werden wir uns auf das Hauptthema unseres Labs konzentrieren: die zeilenweise Ausgabe von Array-Elementen. Wir werden verschiedene Methoden untersuchen, wie man dies in Bash erreichen kann.

Methode 1: Verwendung einer For-Schleife

Der einfachste Weg, um Array-Elemente zeilenweise auszugeben, ist die Verwendung einer For-Schleife:

1. Erstellen Sie eine neue Datei namens print_array_loop.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using a for loop:"
for planet in "${planets[@]}"; do
  echo "$planet"
done

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/print_array_loop.sh

3. Führen Sie das Skript aus:

./print_array_loop.sh

Die Ausgabe zeigt jeden Planeten in einer separaten Zeile:

Printing planets using a for loop:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Methode 2: Verwendung des printf-Befehls

Der printf-Befehl ist oft effizienter als die Verwendung einer Schleife mit echo:

1. Erstellen Sie eine neue Datei namens print_array_printf.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using printf:"
printf "%s\n" "${planets[@]}"

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/print_array_printf.sh

3. Führen Sie das Skript aus:

./print_array_printf.sh

Die Ausgabe ist dieselbe wie bei der vorherigen Methode:

Printing planets using printf:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Methode 3: Verwendung der IFS-Variablen

Die interne Feldtrennzeichen-Variable (Internal Field Separator, IFS) kann verwendet werden, um zu steuern, wie Array-Elemente ausgegeben werden:

1. Erstellen Sie eine neue Datei namens print_array_ifs.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using IFS:"
## Temporarily change IFS to newline
old_IFS="$IFS"
IFS=$'\n'
echo "${planets[*]}" ## Note: using * instead of @ with IFS
IFS="$old_IFS"       ## Restore original IFS

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/print_array_ifs.sh

3. Führen Sie das Skript aus:

./print_array_ifs.sh

Die Ausgabe zeigt erneut jeden Planeten in einer separaten Zeile:

Printing planets using IFS:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Methode 4: Kombination mehrerer Techniken

Kombinieren wir diese Techniken in einem umfassenderen Beispiel:

1. Erstellen Sie eine neue Datei namens print_array_combined.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Using a for loop with index:"
for i in "${!planets[@]}"; do
  echo "Planet $i: ${planets[$i]}"
done

echo -e "\nUsing printf with formatting:"
printf "Planet: %s - %d letters\n" "${planets[@]}" "${#planets[@]}"

echo -e "\nSorted planets:"
printf "%s\n" "${planets[@]}" | sort

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/print_array_combined.sh

3. Führen Sie das Skript aus:

./print_array_combined.sh

Die Ausgabe zeigt verschiedene Möglichkeiten, wie man Array-Elemente formatieren und ausgeben kann:

Using a for loop with index:
Planet 0: Mercury
Planet 1: Venus
Planet 2: Earth
Planet 3: Mars
Planet 4: Jupiter
Planet 5: Saturn
Planet 6: Uranus
Planet 7: Neptune

Using printf with formatting:
Planet: Mercury - 8 letters
Planet: Venus - 5 letters
Planet: Earth - 5 letters
Planet: Mars - 4 letters
Planet: Jupiter - 7 letters
Planet: Saturn - 6 letters
Planet: Uranus - 7 letters
Planet: Neptune - 7 letters

Sorted planets:
Earth
Jupiter
Mars
Mercury
Neptune
Saturn
Uranus
Venus

Jede dieser Methoden hat ihre Vorteile:

• Die For-Schleife ist für Anfänger am leichtesten zu verstehen.
• Die printf-Methode ist für große Arrays effizienter.
• Die IFS-Methode ist kompakt, aber möglicherweise weniger intuitiv.
• Die kombinierte Technik bietet reichhaltige Formatierungsmöglichkeiten.

Wählen Sie die Methode, die am besten zu Ihrem spezifischen Anwendungsfall und Ihrem Codierungsstil passt.

Praktische Anwendungen mit Arrays

In diesem letzten Schritt werden wir reale Anwendungen von Bash-Arrays untersuchen und die Techniken anwenden, die wir für die zeilenweise Ausgabe von Elementen gelernt haben.

Verarbeitung einer Dateiliste

Erstellen wir ein Skript, das Dateien in einem Verzeichnis verarbeitet:

1. Zunächst erstellen wir einige Beispiel-Dateien, mit denen wir arbeiten können:

mkdir -p /home/labex/project/sample_files
touch /home/labex/project/sample_files/file1.txt
touch /home/labex/project/sample_files/file2.txt
touch /home/labex/project/sample_files/file3.txt
touch /home/labex/project/sample_files/image1.jpg
touch /home/labex/project/sample_files/image2.jpg

2. Erstellen Sie eine neue Datei namens process_files.sh:

#!/bin/bash

## Get a list of files in the directory
file_path="/home/labex/project/sample_files"
files=($(ls "$file_path"))

echo "All files in directory:"
printf "%s\n" "${files[@]}"

echo -e "\nProcessing text files only:"
text_files=()

## Filter for text files
for file in "${files[@]}"; do
  if [[ "$file" == *.txt ]]; then
    text_files+=("$file")
  fi
done

## Process each text file
if [ ${#text_files[@]} -eq 0 ]; then
  echo "No text files found."
else
  echo "Found ${#text_files[@]} text files:"
  for file in "${text_files[@]}"; do
    echo "Processing $file..."
    ## Here you would typically do something with each file
    echo "  - Adding content to $file"
    echo "This is sample content" > "$file_path/$file"
  done
fi

## Verify the content
echo -e "\nContent of text files:"
for file in "${text_files[@]}"; do
  echo "--- $file ---"
  cat "$file_path/$file"
  echo "------------"
done

3. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/process_files.sh

4. Führen Sie das Skript aus:

./process_files.sh

Die Ausgabe zeigt, wie man Dateien mit Arrays verarbeitet und filtert:

All files in directory:
file1.txt
file2.txt
file3.txt
image1.jpg
image2.jpg

Processing text files only:
Found 3 text files:
Processing file1.txt...
  - Adding content to file1.txt
Processing file2.txt...
  - Adding content to file2.txt
Processing file3.txt...
  - Adding content to file3.txt

Content of text files:
--- file1.txt ---
This is sample content
------------
--- file2.txt ---
This is sample content
------------
--- file3.txt ---
This is sample content
------------

Erstellung eines einfachen Menüs

Arrays können nützlich sein, um Menüs in Skripten zu erstellen:

1. Erstellen Sie eine neue Datei namens menu_system.sh:

#!/bin/bash

## Define menu options
options=("List Files" "Check Disk Space" "Display Date" "Display Users" "Exit")

while true; do
  echo -e "\nMenu Options:"
  ## Print menu with numbers
  for i in "${!options[@]}"; do
    echo "  $((i + 1)). ${options[$i]}"
  done

  ## Get user choice
  read -p "Enter your choice (1-${#options[@]}): " choice

  ## Convert to zero-based index
  ((choice--))

  ## Process choice
  case $choice in
    0) ## List Files
      echo -e "\nFiles in current directory:"
      ls -la /home/labex/project
      ;;
    1) ## Check Disk Space
      echo -e "\nDisk space usage:"
      df -h
      ;;
    2) ## Display Date
      echo -e "\nCurrent date and time:"
      date
      ;;
    3) ## Display Users
      echo -e "\nCurrently logged in users:"
      who
      ;;
    4) ## Exit
      echo "Exiting menu system. Goodbye!"
      exit 0
      ;;
    *)
      echo "Invalid choice. Please try again."
      ;;
  esac

  ## Pause before showing menu again
  read -p "Press Enter to continue..."
done

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/menu_system.sh

3. Führen Sie das Skript aus:

./menu_system.sh

4. Sie sehen ein Menü. Versuchen Sie, verschiedene Optionen auszuwählen, um die Ergebnisse zu sehen. Wenn Sie fertig sind, wählen Sie Option 5, um das Menü zu verlassen.

Verarbeitung von Befehlsausgaben

Arrays eignen sich hervorragend für die Verarbeitung von Befehlsausgaben:

1. Erstellen Sie eine neue Datei namens process_command_output.sh:

#!/bin/bash

## Get a list of running processes
echo "Getting list of processes..."
processes=($(ps -e | awk '{print $4}' | tail -n +2))

echo "Found ${#processes[@]} processes"
echo -e "\nTop 10 processes:"
printf "%s\n" "${processes[@]:0:10}"

## Count unique processes
echo -e "\nCounting unique process names..."
declare -A process_count

for process in "${processes[@]}"; do
  ((process_count["$process"]++))
done

echo -e "\nProcess Count Summary:"
for process in "${!process_count[@]}"; do
  echo "$process: ${process_count["$process"]}"
done | sort -rn -k2 | head -10

2. Speichern Sie die Datei und machen Sie sie ausführbar:

chmod +x /home/labex/project/process_command_output.sh

3. Führen Sie das Skript aus:

./process_command_output.sh

Die Ausgabe zeigt, wie man Befehlsausgaben mit Arrays verarbeitet. Die genaue Ausgabe variiert je nach den auf Ihrem System laufenden Prozessen.

Diese Beispiele zeigen, wie Bash-Arrays in der Praxis eingesetzt werden können, um praktische Probleme zu lösen. Die Fähigkeit, Listen von Elementen zu verarbeiten und in einem lesbaren Format auszugeben, ist eine grundlegende Fähigkeit für die Shell-Skripting.

Zusammenfassung

In diesem Lab haben Sie essentielle Fähigkeiten für die Arbeit mit Bash-Arrays gelernt:

1. Erstellen und Verstehen von Arrays

   • Deklarieren von Arrays mit verschiedenen Methoden
   • Zugreifen auf Array-Elemente und -Eigenschaften

2. Manipulation von Array-Elementen

   • Hinzufügen, Entfernen und Modifizieren von Elementen
   • Slicing von Arrays und Suchen nach Elementen

3. Zeilenweise Ausgabe von Array-Elementen

   • Verwenden von For-Schleifen, um durch Arrays zu iterieren
   • Verwenden des printf-Befehls für eine effiziente Ausgabe
   • Nutzen der IFS-Variable für benutzerdefinierte Formatierung
   • Kombinieren von Techniken für fortgeschrittene Ausgabeformatierung

4. Praktische Anwendungen

   • Verarbeiten von Dateilisten
   • Erstellen von Menüs
   • Verarbeiten von Befehlsausgaben

Diese Fähigkeiten bilden eine solide Grundlage für die Verwendung von Arrays in Ihren Bash-Skripten. Sie können nun effizient Datenmengen speichern, manipulieren und anzeigen, wodurch Ihre Skripte robuster und vielseitiger werden.

Denken Sie daran, dass die Übung der Schlüssel zum Beherrschen von Bash-Arrays ist. Versuchen Sie, diese Techniken in Ihre eigenen Skripte zu integrieren und entdecken Sie, wie sie Ihnen helfen können, reale Probleme effizient zu lösen.