Les archives regroupent plusieurs fichiers dans un format unique, généralement zip, tar ou rar. Les fichiers d’archives peuvent également utiliser la compression pour réduire la taille totale du fichier.
Vous pouvez utiliser des archives pour distribuer des logiciels et des données, y compris des pages Web. Vous pouvez également archiver votre application, avec tous ses fichiers et dépendances, pour que les utilisateurs puissent la télécharger et l’installer.
Le paquetage d’archives de Go vous permet de créer et d’extraire des archives aux formats tar et zip.
Paquet d’archives de Go
Go fournit archive paquets permettant de travailler avec différents formats d’archives. Vous pouvez utiliser les paquets zip et tar pour créer, lire et écrire des fichiers d’archive dans ces formats. Les deux paquets prennent en charge divers algorithmes de compression via une API facile à utiliser.
Voici comment vous pouvez importer les paquets zip et tar dans vos fichiers Go :
import (
"archive/zip"
"archive/tar"
)
Après avoir importé les paquets, vous pouvez les utiliser pour créer et manipuler des fichiers d’archives.
Créer et ajouter des fichiers aux archives Tar
Le site tar Le paquet fonctionne avec les archives tar des formats tar et tar.gz, y compris la prise en charge de la lecture et de l’écriture des fichiers avec des en-têtes étendus PAX.
Le paquet tar fournit un NewWriter Fonction permettant de créer de nouvelles archives tar. NewWriter prend un io.Writer qui peut être un fichier ou un tampon de mémoire et renvoie un pointeur vers l’instance de l’interface tar.Writer struct.
package main
import (
"archive/tar"
"os"
)
func main() {
// Create a new file
file, _ := os.Create("myarchive.tar")
defer file.Close()
// Create a new tar archive
tarWriter := tar.NewWriter(file)
defer tarWriter.Close()
}
Le site Créer fonction de la os Le paquet crée un nouveau fichier tar. Le site tar.NewWriter prend un fichier et crée une nouvelle archive.
Vous pouvez ajouter des fichiers à l’archive tar avec la fonction WriteHeader et Écrire fonctions. La fonction WriteHeader prend un tar.Header struct comme argument. Elle contient les métadonnées du fichier, telles que le nom du fichier, sa taille et les bits de permission. La fonction Write écrit le contenu d’un fichier dans l’archive.
import (
"archive/tar"
"fmt"
"io"
"log"
"os"
)
func main() {
// Create a new file
file, _ := os.Create("myarchive.tar")
file, _ = os.Create("message.txt")
defer file.Close()
// Create a new tar archive
tarWriter := tar.NewWriter(file)
defer tarWriter.Close()
// Add a file to the archive
fileToAdd, _ := os.Open("file1.txt")
defer fileToAdd.Close()
fileInfo, _ := fileToAdd.Stat()
header, _ := tar.FileInfoHeader(fileInfo, "")
tarWriter.WriteHeader(header)
_, _ = io.Copy(tarWriter, fileToAdd)
fmt.Println("TAR archive operation completed")
}
Le programme crée de nouveaux fichiers tar et texte avec la fonction Créer fonction de la os et une nouvelle archive tar avec le paquet NewWriteravant d’ajouter le fichier à l’archive.
Le site Ouvrir ouvre le fichier à ajouter à l’archive. Notez que vous aurez besoin d’un fichier nommé fichier1.txt dans votre répertoire de travail pour exécuter ce programme avec succès.
Vous pouvez utiliser l’option Stat d’une instance de fichier pour récupérer les métadonnées dont vous aurez besoin pour l’en-tête tar. Passez son résultat à FileInfoHeaderpuis transmet ce résultat à le site WriteHeader pour configurer le fichier tar. Enfin, copiez le fichier dans l’archive en utilisant io.Copy.
Extraction de fichiers à partir d’archives Tar
Vous pouvez utiliser la fonction NewReader pour lire le contenu du fichier d’archive tar. La fonction NewReader prend en entrée un io.Reader qui peut être un fichier ou une mémoire tampon. Elle retourne un pointeur vers un tar.Reader struct.
import (
"archive/tar"
"io"
"os"
)
func main() {
// Open the tar archive
file, _ := os.Open("myarchive.tar")
defer file.Close()
// Create a new tar reader
tarReader := tar.NewReader(file)
// Iterate over the files in the archive
for {
header, err := tarReader.Next()
if err == io.EOF {
break
}
// Extract the file
outFile, _ := os.Create(header.Name)
defer outFile.Close()
_, _ = io.Copy(outFile, tarReader)
}
}
La boucle infinie for parcourt l’instance du lecteur tar et extrait les fichiers en copiant chaque fichier avec la balise io Le paquet Copie fonction.
Création et ajout de fichiers dans les archives Zip
Vous pouvez créer une nouvelle archive zip avec la commande NewWriter de la fonction zip paquet. La fonction NewWriter prend une instance de fichier et renvoie un graveur zip.
import (
"archive/zip"
"os"
)
func main() {
// Create a new file
file, err := os.Create("archive.zip")
if err != nil {
panic(err)
}
defer file.Close()
// Create a new zip writer
zipWriter := zip.NewWriter(file)
defer zipWriter.Close()
}
Le site zipWriter La variable stocke une nouvelle Rédacteur instance que NewWriter renvoie.
Vous pouvez ajouter des fichiers à vos archives zip avec la fonction Créer de l’instance Writer. La fonction Create prend en compte le nom du fichier. Vous pouvez également utiliser la fonction Write Fonction de l’instance du fichier zip pour écrire des données dans les fichiers des archives zip.
import (
"archive/zip"
"os"
)
func main() {
// Create new files
file, err := os.Create("archive.zip")
file, err = os.Create("file1.txt")
file, err = os.Create("file2.txt")
if err != nil {
panic(err)
}
defer file.Close()
// Create a new zip writer
zipWriter := zip.NewWriter(file)
defer zipWriter.Close()
// Add files to the archive
file1, err := zipWriter.Create("file1.txt")
if err != nil {
panic(err)
}
file2, err := zipWriter.Create("file2.txt")
if err != nil {
panic(err)
}
// Write data to the files in the archive
file1.Write([]byte("Hello, World!"))
file2.Write([]byte("Goodbye, World!"))
fmt.Println("zip archiving operation completed")
}
La fonction principale commence par utiliser Créer pour créer un nouveau fichier zip et deux fichiers texte. Il crée ensuite deux Writers pour ajouter les deux fichiers texte à l’archive. Le site Write La fonction de chaque instance de fichier écrit des messages dans chacun des fichiers de l’archive.
Extraction de fichiers d’une archive zip
Vous pouvez extraire un fichier zip existant en le lisant avec la commande OpenReader puis en parcourant son contenu en boucle et en copiant les fichiers avec la fonction io paquet.
import (
"archive/zip"
"fmt"
"io"
"os"
)
func main() {
// Open the archive
zipReader, err := zip.OpenReader("archive.zip")
if err != nil {
panic(err)
}
defer zipReader.Close()
// Extract files from the archive
for _, file := range zipReader.File {
zippedFile, err := file.Open()
if err != nil {
panic(err)
}
defer zippedFile.Close()
// Create a new file with the same name as the zipped file
extractedFile, err := os.Create(file.Name)
if err != nil {
panic(err)
}
defer extractedFile.Close()
// Copy the data from the zipped file to the new file
_, err = io.Copy(extractedFile, zippedFile)
if err != nil {
panic(err)
}
fmt.Printf("Extracted %s\n", file.Name)
}
}
Le site OpenReader La fonction OpenReader lit les archives zip. Le site OpenReader accepte le nom du fichier zip comme argument et renvoie une instance de lecteur de fichier zip. Le site pour la gamme parcourt le contenu des fichiers dans l’instance du lecteur. Elle crée un nouveau fichier avec le même nom que le fichier d’origine, et copie le contenu du fichier extrait dans le nouveau fichier en utilisant la commande io.Copy fonction.
Dézipper manuellement ou par programme : à vous de voir !
Dézipper des fichiers de façon programmatique est pratique si vous avez beaucoup de fichiers ou d’archives à dézipper. Vous pouvez également intégrer la fonctionnalité d’archivage dans votre application principale.
Dans d’autres cas, il est préférable d’utiliser des applications existantes. Vous pouvez utiliser des applications intégrées ou tierces pour décompresser des archives sous Windows, macOS et Linux.