Linux-Wildcard-Zeichen

Einführung

Linux-Wildcards (Platzhalter) sind Sonderzeichen, die es Ihnen ermöglichen, mehrere Dateien gleichzeitig anhand von Mustern in ihren Namen zu suchen und zu verwalten. Sie sind leistungsstarke Werkzeuge für die effiziente Verwaltung von Dateien in der Befehlszeilenumgebung. In diesem Lab (Praktikum) werden Sie lernen, wie Sie verschiedene Wildcards verwenden, um häufige Operationen wie das Auflisten, Kopieren und Löschen von Dateien anhand von Musterabgleich durchzuführen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL linux(("Linux")) -.-> linux/BasicFileOperationsGroup(["Basic File Operations"]) linux(("Linux")) -.-> linux/FileandDirectoryManagementGroup(["File and Directory Management"]) linux/BasicFileOperationsGroup -.-> linux/ls("Content Listing") linux/BasicFileOperationsGroup -.-> linux/cp("File Copying") linux/BasicFileOperationsGroup -.-> linux/mv("File Moving/Renaming") linux/BasicFileOperationsGroup -.-> linux/rm("File Removing") linux/FileandDirectoryManagementGroup -.-> linux/cd("Directory Changing") linux/FileandDirectoryManagementGroup -.-> linux/mkdir("Directory Creating") linux/FileandDirectoryManagementGroup -.-> linux/wildcard("Wildcard Character") subgraph Lab Skills linux/ls -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/cp -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/mv -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/rm -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/cd -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/mkdir -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} linux/wildcard -.-> lab-271447{{"Linux-Wildcard-Zeichen"}} end

Das Sternchen (*) Wildcard verstehen

Das Sternchen * ist das am häufigsten verwendete Wildcard-Zeichen in Linux. Es steht für eine beliebige Anzahl von Zeichen (einschließlich null Zeichen) in einem Dateinamen. Dies macht es unglaublich nützlich für die Arbeit mit Gruppen von Dateien, die ähnliche Namensmuster aufweisen.

Üben wir die Verwendung des Sternchen-Wildcards:

Öffnen Sie zunächst Ihr Terminal und navigieren Sie in das Projektverzeichnis:
```
cd ~/project
```
Erstellen Sie ein Übungsverzeichnis für dieses Lab und navigieren Sie hinein:
```
mkdir -p wildcard_practice
cd wildcard_practice
```
Jetzt erstellen wir einige Beispiel-Dateien, mit denen wir arbeiten können:
```
touch file1.txt file2.txt file3.txt document1.pdf document2.pdf image.jpg
```
Verwenden Sie den ls-Befehl, um alle Dateien im Verzeichnis aufzulisten:
```
ls
```
Sie sollten alle Dateien sehen, die Sie gerade erstellt haben:
```
document1.pdf  document2.pdf  file1.txt  file2.txt  file3.txt  image.jpg
```
Jetzt verwenden wir das Sternchen-Wildcard, um nur die Textdateien aufzulisten:
```
ls *.txt
```
Dieser Befehl sollte nur die Dateien anzeigen, die mit .txt enden:
```
file1.txt  file2.txt  file3.txt
```
Sie können das Wildcard auch verwenden, um Dateien zu finden, die mit einem bestimmten Muster beginnen. Um alle Dateien aufzulisten, die mit "file" beginnen:
```
ls file*
```
Dieser Befehl sollte anzeigen:
```
file1.txt  file2.txt  file3.txt
```
Um alle PDF-Dokumente aufzulisten:
```
ls *.pdf
```
Dieser Befehl sollte anzeigen:
```
document1.pdf  document2.pdf
```

Das Sternchen-Wildcard ist vielseitig und kann an jeder Position im Muster verwendet werden. Beispielsweise würde *1* jede Datei treffen, die "1" irgendwo in ihrem Namen enthält.

Die Verwendung von Wildcards mit dem Fragezeichen (?)

Das Fragezeichen ? als Wildcard steht für genau ein Zeichen. Es ist nützlich, wenn Sie Dateien mit ähnlichen Namen übereinstimmen lassen möchten, die sich jedoch an einer bestimmten Position um ein einzelnes Zeichen unterscheiden.

Lassen Sie uns untersuchen, wie das Fragezeichen-Wildcard funktioniert:

Stellen Sie sicher, dass Sie sich noch im Verzeichnis wildcard_practice befinden:
```
cd ~/project/wildcard_practice
```
Erstellen wir einige zusätzliche Dateien, um das Fragezeichen-Wildcard besser zu demonstrieren:
```
touch file-a.txt file-b.txt file-c.txt test1.log test2.log test3.log
```
Um alle "file-?.txt"-Dateien aufzulisten, wobei ? ein einzelnes Zeichen ist:
```
ls file-?.txt
```
Dieser Befehl sollte anzeigen:
```
file-a.txt  file-b.txt  file-c.txt
```
Ebenso, um alle "test?.log"-Dateien aufzulisten:
```
ls test?.log
```
Die Ausgabe sollte sein:
```
test1.log  test2.log  test3.log
```
Sie können mehrere Fragezeichen kombinieren, um mehrere einzelne Zeichen zu übereinstimmen. Beispielsweise, um alle Textdateien mit Namen in der Form "file?" zu übereinstimmen:
```
ls file?.txt
```
Dies sollte anzeigen:
```
file1.txt  file2.txt  file3.txt
```
Das Fragezeichen-Wildcard ist besonders nützlich, wenn Sie ein bestimmtes Muster mit Variationen an exakten Positionen übereinstimmen lassen müssen. Beispielsweise, wenn Sie Dateien möchten, die mit einer einstelligen Zahl gefolgt von .log enden:
```
ls test?.log
```

Das Fragezeichen-Wildcard ist spezifischer als das Sternchen, da es genau ein Zeichen übereinstimmt, während das Sternchen eine beliebige Anzahl von Zeichen übereinstimmen kann.

Die Verwendung von eckigen Klammern [] für Zeichenklassen

Die eckigen Klammern [] als Wildcard ermöglichen es Ihnen, eine Menge oder einen Bereich von Zeichen anzugeben, die an einer bestimmten Position in einem Dateinamen übereinstimmen sollen. Dies bietet eine höhere Präzision als die Sternchen- oder Fragezeichen-Wildcards.

Üben wir die Verwendung der eckigen Klammern als Wildcard:

Stellen Sie sicher, dass Sie sich noch im Verzeichnis wildcard_practice befinden:
```
cd ~/project/wildcard_practice
```
Erstellen wir einige zusätzliche Dateien, mit denen wir arbeiten können:
```
touch data-1.csv data-2.csv data-3.csv data-a.csv data-b.csv
```
Um Dateien aufzulisten, die an einer bestimmten Position eine Ziffer haben, können Sie die Klammer-Schreibweise mit einem Bereich verwenden:
```
ls data-[1-3].csv
```
Dies sollte anzeigen:
```
data-1.csv  data-2.csv  data-3.csv
```
Ebenso, um Dateien aufzulisten, die an dieser Position einen Buchstaben haben:
```
ls data-[a-z].csv
```
Dies sollte anzeigen:
```
data-a.csv  data-b.csv
```
Sie können auch bestimmte Zeichen innerhalb der Klammern auflisten. Beispielsweise, um Dateien mit entweder '1' oder 'a' nach "data-" aufzulisten:
```
ls data-[1a].csv
```
Dies sollte anzeigen:
```
data-1.csv  data-a.csv
```
Das Caret-Symbol ^ innerhalb der eckigen Klammern negiert die Übereinstimmung. Um alle "data-" -Dateien aufzulisten, außer diejenigen, die mit "1" oder "2" enden:
```
ls data-[^12].csv
```
Dieser Befehl sollte anzeigen:
```
data-3.csv  data-a.csv  data-b.csv
```

Eckige Klammern bieten eine präzise Kontrolle, wenn Sie Dateien übereinstimmen lassen müssen, die sich an bestimmten Positionen durch bestimmte Zeichen unterscheiden.

Praktische Dateioperationen mit Wildcards

Nachdem wir nun die verschiedenen Arten von Wildcards verstehen, nutzen wir sie, um häufige Dateioperationen wie Kopieren, Verschieben und Löschen von Dateien auszuführen.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis wildcard_practice befinden:
```
cd ~/project/wildcard_practice
```
Erstellen wir ein Backup-Verzeichnis, um Kopien unserer Dateien zu speichern:
```
mkdir backup
```
Kopieren Sie alle Textdateien in das Backup-Verzeichnis mithilfe des Sternchen-Wildcards:
```
cp *.txt backup/
```
Überprüfen wir, ob die Dateien korrekt kopiert wurden:
```
ls backup/
```
Sie sollten alle Textdateien im Backup-Verzeichnis sehen:
```
file-a.txt  file-b.txt  file-c.txt  file1.txt  file2.txt  file3.txt
```
Jetzt erstellen wir ein weiteres Verzeichnis, um verschiedene Dateitypen zu organisieren:
```
mkdir csv_files pdf_files log_files
```
Verschieben Sie alle CSV-Dateien in das csv_files-Verzeichnis:
```
mv *.csv csv_files/
```
Verschieben Sie alle PDF-Dateien in das pdf_files-Verzeichnis:
```
mv *.pdf pdf_files/
```
Verschieben Sie alle Log-Dateien in das log_files-Verzeichnis:
```
mv *.log log_files/
```
Überprüfen wir, ob jedes Verzeichnis die richtigen Dateien enthält:
```
echo "CSV Files:"
ls csv_files/
echo "PDF Files:"
ls pdf_files/
echo "Log Files:"
ls log_files/
```
Die Ausgabe sollte die entsprechenden Dateien in jedem Verzeichnis anzeigen.
Schließlich bereinigen wir, indem wir alle Backup-Textdateien löschen, deren Name eine Zahl enthält:
```
rm backup/file[0-9].txt
```
Überprüfen Sie, ob nur die Textdateien mit Buchstaben im Namen im Backup-Verzeichnis verbleiben:
```
ls backup/
```
Die Ausgabe sollte folgendes anzeigen:
```
file-a.txt  file-b.txt  file-c.txt
```

Diese Beispiele zeigen, wie Wildcards Dateiverwaltungstasks erheblich vereinfachen können, die andernfalls mehrere Befehle oder die manuelle Bearbeitung einzelner Dateien erfordern würden.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Linux-Wildcards verwenden können, um Dateien effizient zu verwalten und zu manipulieren. Die behandelten Schlüsselkonzepte umfassen:

Die Verwendung des Sternchens (*) als Wildcard, um eine beliebige Anzahl von Zeichen zu matchen
Die Verwendung des Fragezeichens (?) als Wildcard, um genau ein Zeichen zu matchen
Die Verwendung von eckigen Klammern [] zur Übereinstimmung mit bestimmten Zeichen oder Zeichenbereichen
Die Anwendung von Wildcards auf häufige Dateioperationen wie das Auflisten, Kopieren und Löschen von Dateien

Diese Wildcard-Techniken sind unverzichtbare Werkzeuge für jeden Linux-Benutzer. Sie sparen Zeit und reduzieren Fehler bei der Arbeit mit mehreren Dateien. Mit ihnen können Sie komplexe Dateioperationen mit einfachen und prägnanten Befehlen ausführen, anstatt jede Datei einzeln bearbeiten zu müssen.

Wenn Sie weiterhin mit Linux-Systemen arbeiten, werden Sie zahlreiche Möglichkeiten finden, diese Wildcard-Muster anzuwenden, um Ihren Arbeitsablauf zu optimieren und Ihre Produktivität zu erhöhen.