So listen Sie den Inhalt eines Zip-Archivs unter Linux auf

LinuxLinuxBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Dieses Tutorial führt Sie durch den Prozess der Auflistung des Inhalts eines Zip-Archivs auf Ihrem Linux-System. Egal, ob Sie Entwickler, Systemadministrator oder einfach nur ein neugieriger Linux-Benutzer sind, das Verständnis für die Arbeit mit Zip-Dateien über die Befehlszeile ist eine wertvolle Fähigkeit. Wir werden die Grundlagen von Zip-Archiven behandeln, die Schritte zur Auflistung ihres Inhalts demonstrieren und praktische Anwendungsfälle und Beispiele bereitstellen, die Ihnen helfen, Ihre Dateien effizienter zu verwalten.

Installation der ZIP-Dienstprogramme

Um mit Zip-Archiven in Linux zu arbeiten, müssen die entsprechenden Dienstprogramme installiert sein. Die wichtigsten Tools, die wir benötigen, sind die Befehle zip und unzip.

Lassen Sie uns überprüfen, ob diese Dienstprogramme bereits auf Ihrem System installiert sind. Öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus:

which zip
which unzip

Wenn diese Befehle Pfade wie /usr/bin/zip und /usr/bin/unzip zurückgeben, sind die Tools bereits installiert. Wenn Sie keine Ausgabe sehen, müssen wir sie installieren.

Unter Ubuntu können wir die Zip-Dienstprogramme mit dem apt Paketmanager installieren:

sudo apt update
sudo apt install -y zip unzip

Lassen Sie uns die Installation überprüfen:

zip --version
unzip -v | head -n 1

Die Ausgabe sollte die installierten Versionen der Zip-Dienstprogramme anzeigen, ähnlich wie diese:

Copyright (c) 1990-2008 Info-ZIP - Type 'zip "-L"' for software license.
UnZip 6.00 of 20 April 2009, by Debian. Original by Info-ZIP.

Nachdem wir nun die notwendigen Tools installiert haben, sind wir bereit, Zip-Archive zu erstellen und mit ihnen zu arbeiten.

Erstellung eines Beispiel-Zip-Archivs

Bevor wir lernen, wie man den Inhalt eines Zip-Archivs auflistet, erstellen wir eine Beispiel-Zip-Datei, mit der wir arbeiten können. Dies gibt uns ein praktisches Beispiel, das wir in diesem Tutorial verwenden können.

Erstellen wir zunächst ein Verzeichnis, in dem wir unsere Beispieldateien speichern. Führen Sie die folgenden Befehle in Ihrem Terminal aus:

mkdir -p ~/project/zip_demo
cd ~/project/zip_demo

Erstellen wir nun einige Beispieldateien mit unterschiedlichem Inhalt:

echo "This is a text file for our zip demo." > sample_text.txt
echo "Another text file with different content." > another_text.txt
mkdir -p documents
echo "This file is inside a subdirectory." > documents/nested_file.txt

Lassen Sie uns überprüfen, ob unsere Dateien korrekt erstellt wurden:

ls -la
ls -la documents

Sie sollten eine ähnliche Ausgabe sehen wie:

total 20
drwxrwxr-x 3 labex labex 4096 Jul 15 10:00 .
drwxr-xr-x 3 labex labex 4096 Jul 15 10:00 ..
-rw-rw-r-- 1 labex labex   39 Jul 15 10:00 another_text.txt
drwxrwxr-x 2 labex labex 4096 Jul 15 10:00 documents
-rw-rw-r-- 1 labex labex   35 Jul 15 10:00 sample_text.txt

total 12
drwxrwxr-x 2 labex labex 4096 Jul 15 10:00 .
drwxrwxr-x 3 labex labex 4096 Jul 15 10:00 ..
-rw-rw-r-- 1 labex labex   36 Jul 15 10:00 nested_file.txt

Erstellen wir nun ein Zip-Archiv, das diese Dateien enthält:

zip -r sample_archive.zip sample_text.txt another_text.txt documents/

Die Option -r weist den Befehl zip an, alle Dateien und Unterverzeichnisse rekursiv einzubeziehen.

Sie sollten eine ähnliche Ausgabe sehen wie:

  adding: sample_text.txt (stored 35 bytes)
  adding: another_text.txt (stored 39 bytes)
  adding: documents/ (stored 0 bytes)
  adding: documents/nested_file.txt (stored 36 bytes)

Jetzt haben wir ein Zip-Archiv namens sample_archive.zip erstellt, das unsere Beispieldateien und -verzeichnisse enthält. Im nächsten Schritt werden wir lernen, wie man den Inhalt dieses Archivs auflistet.

Grundlegende Methoden zum Auflisten von Zip-Inhalten

Nachdem wir ein Beispiel-Zip-Archiv erstellt haben, lernen wir, wie man dessen Inhalt auflistet. Der primäre Befehl hierfür ist unzip mit verschiedenen Optionen.

Verwenden der Option -l (List)

Die gebräuchlichste Methode zum Auflisten des Inhalts eines Zip-Archivs ist die Verwendung des Befehls unzip mit der Option -l. Diese Option zeigt eine Tabelle mit grundlegenden Informationen zu jeder Datei im Archiv an.

Navigieren wir zu unserem Zip-Demo-Verzeichnis und listen wir den Inhalt unseres Beispielarchivs auf:

cd ~/project/zip_demo
unzip -l sample_archive.zip

Sie sollten eine ähnliche Ausgabe sehen wie:

Archive:  sample_archive.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
       35  2023-07-15 10:00   sample_text.txt
       39  2023-07-15 10:00   another_text.txt
        0  2023-07-15 10:00   documents/
       36  2023-07-15 10:00   documents/nested_file.txt
---------                     -------
      110                     4 files

Die Ausgabe zeigt:

  • Die Größe jeder Datei in Bytes
  • Das Datum und die Uhrzeit, wann jede Datei zuletzt geändert wurde
  • Den Namen jeder Datei oder jedes Verzeichnisses
  • Eine Zusammenfassung mit der Gesamtgröße und Anzahl der Dateien

Verwenden der Option -Z (ZipInfo)

Eine andere Option ist die Verwendung der Option -Z, die eine präzisere Auflistung bietet:

unzip -Z sample_archive.zip

Sie sollten eine ähnliche Ausgabe sehen wie:

Archive:  sample_archive.zip
Zip file size: 676 bytes, number of entries: 4
-rw-rw-r--  3.0 unx       35 tx defN 23-Jul-15 10:00 sample_text.txt
-rw-rw-r--  3.0 unx       39 tx defN 23-Jul-15 10:00 another_text.txt
drwxrwxr-x  3.0 unx        0 bx stor 23-Jul-15 10:00 documents/
-rw-rw-r--  3.0 unx       36 tx defN 23-Jul-15 10:00 documents/nested_file.txt
4 files, 110 bytes uncompressed, 110 bytes compressed:  0.0%

Dieses Format zeigt Dateiberechtigungen, Komprimierungsinformationen und andere Details in einer kompakteren Form an.

Im nächsten Schritt werden wir weitere erweiterte Optionen zum Auflisten von Zip-Inhalten untersuchen und verstehen, wie man die Ergebnisse interpretiert.

Erweiterte Optionen zum Anzeigen von Zip-Inhalten

Lassen Sie uns nun einige erweiterte Optionen zum Auflisten von Zip-Archiv-Inhalten untersuchen, die detailliertere Informationen über die Dateien im Archiv liefern.

Verwenden der Option -v (Verbose/Ausführlich)

Die Option -v liefert detailliertere Informationen zu jeder Datei im Archiv, einschließlich der Komprimierungsmethode, des Komprimierungsverhältnisses und der CRC-Werte (Cyclic Redundancy Check/zyklische Redundanzprüfung):

cd ~/project/zip_demo
unzip -v sample_archive.zip

Sie sollten eine ähnliche Ausgabe sehen wie:

Archive:  sample_archive.zip
 Length   Method    Size  Cmpr    Date    Time   CRC-32   Name
--------  ------  ------- ---- ---------- ----- --------  ----
      35  Stored       35   0% 2023-07-15 10:00 a1b2c3d4  sample_text.txt
      39  Stored       39   0% 2023-07-15 10:00 e5f6g7h8  another_text.txt
       0  Stored        0   0% 2023-07-15 10:00 00000000  documents/
      36  Stored       36   0% 2023-07-15 10:00 i9j0k1l2  documents/nested_file.txt
--------          -------  ---                            -------
     110             110   0%                            4 files

Diese Ausgabe liefert die folgenden zusätzlichen Informationen:

  • Method: Die verwendete Komprimierungsmethode (in diesem Fall bedeutet "Stored", dass keine Komprimierung erfolgte)
  • Size: Die komprimierte Größe der Datei
  • Cmpr: Das Komprimierungsverhältnis als Prozentsatz
  • CRC-32: Ein Prüfsummenwert zur Überprüfung der Dateiintegrität

Filtern der Ausgabe mit Grep

Manchmal möchten Sie möglicherweise überprüfen, ob eine bestimmte Datei in einem großen Zip-Archiv vorhanden ist. Sie können den Befehl unzip -l mit grep kombinieren, um nach bestimmten Dateien zu suchen:

unzip -l sample_archive.zip | grep "nested_file"

Dieser Befehl zeigt nur Einträge an, die den Text "nested_file" in ihren Namen enthalten:

       36  2023-07-15 10:00   documents/nested_file.txt

Zählen von Dateien in einem Zip-Archiv

Um die Anzahl der Dateien in einem Zip-Archiv zu zählen, können Sie den folgenden Befehl verwenden:

unzip -l sample_archive.zip | grep -v "Archive:" | grep -v "Length" | grep -v "-------" | grep -v "^$" | wc -l

Dieser Befehl filtert Kopf- und Fußzeilen heraus und zählt die verbleibenden Zeilen, die Dateien und Verzeichnissen im Archiv entsprechen.

Die Ausgabe sollte sein:

4

Jetzt wissen Sie, wie Sie erweiterte Optionen verwenden können, um detailliertere Informationen über den Inhalt von Zip-Archiven zu erhalten, nach bestimmten Dateien zu suchen und die Dateien in einem Archiv zu zählen.

Praktische Anwendungsfälle und Beispiele

Nachdem wir gelernt haben, wie man den Inhalt von Zip-Archiven auflistet, wollen wir nun einige praktische Szenarien untersuchen, in denen diese Fähigkeiten nützlich sein können. Wir werden mit realistischeren Beispielen arbeiten, denen Sie im täglichen Linux-Gebrauch begegnen könnten.

Erstellen eines Backup-Archivs

Das Erstellen von Backups ist ein häufiger Anwendungsfall für Zip-Archive. Erstellen wir ein Backup unserer Konfigurationsdateien:

cd ~/project/zip_demo
mkdir -p config
echo "server_name=example.com" > config/server.conf
echo "user=admin" > config/user.conf
echo "port=8080" > config/port.conf

## Create a dated backup archive (Erstelle ein datiertes Backup-Archiv)
zip -r backup_$(date +%Y%m%d).zip config/

Der Befehl erstellt eine Backup-Datei mit dem heutigen Datum im Format backup_YYYYMMDD.zip.

Überprüfen wir den Inhalt unseres Backups:

unzip -l backup_*.zip

Sie sollten eine Ausgabe sehen, die alle Konfigurationsdateien auflistet, die wir gerade gesichert haben.

Vergleichen von Archivinhalten

Manchmal müssen Sie den Inhalt von zwei Zip-Archiven vergleichen, um festzustellen, was sich geändert hat. Erstellen wir ein zweites Backup mit einigen Änderungen:

## Modify a file (Ändere eine Datei)
echo "port=9090" > config/port.conf
## Add a new file (Füge eine neue Datei hinzu)
echo "debug=true" > config/debug.conf
## Create a new backup (Erstelle ein neues Backup)
zip -r backup_new.zip config/

Vergleichen wir nun den Inhalt der beiden Backup-Dateien:

## List files in the first backup (Liste Dateien im ersten Backup auf)
echo "Original backup:"
unzip -l backup_*.zip | grep -v "Archive:" | grep -v "Length" | grep -v -e "-------"

## List files in the new backup (Liste Dateien im neuen Backup auf)
echo -e "\nNew backup:"
unzip -l backup_new.zip | grep -v "Archive:" | grep -v "Length" | grep -v -e "-------"

Sie werden feststellen, dass das neue Backup die zusätzliche Datei debug.conf enthält und die Datei port.conf aufgrund unserer Änderungen möglicherweise eine andere Größe hat.

Extrahieren bestimmter Dateien

Sie können die Informationen, die Sie durch das Auflisten von Zip-Inhalten erhalten haben, verwenden, um nur bestimmte Dateien zu extrahieren:

## Create a directory for extraction (Erstelle ein Verzeichnis für die Extraktion)
mkdir -p extracted

## List the contents first (Liste zuerst den Inhalt auf)
unzip -l backup_new.zip

## Extract only the debug.conf file (Extrahiere nur die Datei debug.conf)
unzip backup_new.zip "config/debug.conf" -d extracted/

Überprüfen wir, ob nur die angeforderte Datei extrahiert wurde:

ls -la extracted/config/

Sie sollten nur die Datei debug.conf im extrahierten Verzeichnis sehen.

Durch die Beherrschung dieser praktischen Beispiele verfügen Sie nun über die Fähigkeiten, Zip-Archive in verschiedenen realen Szenarien effektiv zu verwalten. Von der Erstellung von Backups über den Vergleich von Archivinhalten bis hin zur selektiven Extraktion von Dateien helfen Ihnen diese Techniken, Ihre Dateien in Linux effizienter zu verwalten.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie in Linux mit Zip-Archiven arbeiten und sich dabei auf das Auflisten ihrer Inhalte konzentrieren. Hier ist eine Zusammenfassung dessen, was wir behandelt haben:

  1. Installation der erforderlichen Zip-Dienstprogramme auf Ihrem Linux-System
  2. Erstellung von Beispiel-Zip-Archiven zum Arbeiten
  3. Verwendung grundlegender Befehle wie unzip -l zum Auflisten von Archivinhalten
  4. Erkundung erweiterter Optionen wie unzip -v für detaillierte Informationen
  5. Anwendung dieser Fähigkeiten in praktischen Szenarien wie dem Erstellen von Backups, dem Vergleichen von Archiven und dem Extrahieren bestimmter Dateien

Diese Fähigkeiten sind wertvoll für die Dateiverwaltung, Fehlerbehebung, Backups und verschiedene andere Aufgaben in Linux. Sie können Zip-Archive nun sicher inspizieren, ohne sie zu extrahieren, was Zeit und Speicherplatz sparen kann, wenn Sie mit großen Archiven arbeiten.

Einige wichtige Befehle, die Sie sich merken sollten:

  • unzip -l archive.zip: Grundlegende Auflistung der Archivinhalte
  • unzip -v archive.zip: Ausführliche (verbose) Auflistung mit Komprimierungsdetails
  • unzip -Z archive.zip: Kurzes (concise) Auflistungsformat
  • unzip -l archive.zip | grep "filename": Suchen nach bestimmten Dateien

Mit diesen Befehlen können Sie Zip-Archive in Ihrer Linux-Umgebung effizient verwalten.