Gli archivi raggruppano diversi file in un unico formato, in genere zip, tar o rar. I file di archivio possono anche utilizzare la compressione per ridurre la dimensione totale del file.
È possibile utilizzare gli archivi per distribuire software e dati, comprese le pagine web. Puoi anche archiviare la tua applicazione, con tutti i suoi file e dipendenze, affinché gli utenti possano scaricarla e installarla.
Il pacchetto archivio di Go ti consente di creare ed estrarre archivi nei formati tar e zip.
Go's Archive Package
Vai fornisce archivio pacchetti per lavorare con vari formati di archivio. Puoi usare il cerniera lampo E catrame packages per creare, leggere e scrivere file di archivio in quei formati. Entrambi i pacchetti supportano vari algoritmi di compressione su un'API facile da usare.
Ecco come puoi importare i pacchetti zip e tar nei tuoi file Go:
importare (
"archivio/zip"
"archivio/tar"
)
Dopo aver importato i pacchetti, è possibile utilizzarli per creare e manipolare i file di archivio.
Creazione e aggiunta di file agli archivi Tar
IL catrame pacchetto funziona con tar archivi di formati tar e tar.gz, incluso il supporto per la lettura e la scrittura di file con intestazioni estese PAX.
Il pacchetto tar fornisce un file Nuovo scrittore funzione per la creazione di nuovi archivi tar. NewWriter accetta un file io. scrittore istanza di interfaccia che può essere un file o un buffer di memoria e restituisce un puntatore a catrame. scrittore struct.
pacchetto principaleimportare (
"archivio/tar"
"os"
)funzprincipale() {
// Crea un nuovo file
file, _ := os. Creare("mioarchivio.tar")
differire file. Vicino()
// Crea un nuovo archivio tar
tarWriter := tar. NewWriter (file)
differire tarWriter. Vicino()
}
IL Creare funzione del os package crea un nuovo file tar. IL catrame. Nuovo scrittore la funzione accetta un file e crea un nuovo archivio.
È possibile aggiungere file all'archivio tar con l'estensione ScriviIntestazione E Scrivere funzioni. La funzione WriteHeader accetta a catrame. Intestazione struct come argomento. Questo contiene i metadati del file, come il nome del file, la dimensione e i bit di autorizzazione. La funzione Write scrive il contenuto di un file nell'archivio.
importare (
"archivio/tar"
"fmt"
"io"
"tronco d'albero"
"os"
)funzprincipale() {
// Crea un nuovo file
file, _ := os. Creare("mioarchivio.tar")
file, _ = os. Creare("messaggio.txt")
differire file. Vicino()// Crea un nuovo archivio tar
tarWriter := tar. NewWriter (file)
differire tarWriter. Vicino()
// Aggiunge un file all'archivio
fileToAdd, _ := os. Aprire("file1.txt")
differire fileToAdd. Vicino()
fileInfo, _ := fileToAdd. Statistica()
intestazione, _ := tar. FileInfoHeader (fileInfo, "")
tarWriter. WriteHeader (intestazione)
_, _ = io. Copia (tarWriter, fileToAdd)
fmt. Stampaln("Operazione archivio TAR completata")
}
Il programma crea nuovi file tar e di testo con l'estensione Creare funzione del os pacchetto e un nuovo archivio tar con il Nuovo scrittore, prima di aggiungere il file all'archivio.
IL Aprire La funzione apre il file da aggiungere all'archivio. Nota che avrai bisogno di un file chiamato file1.txt nella tua directory di lavoro per eseguire correttamente questo programma.
Puoi usare il statistica funzione di un'istanza di file per recuperare i metadati necessari per l'intestazione tar. Passa il suo risultato a FileInfoHeader, quindi passa il risultato athe ScriviIntestazione funzione per impostare il file tar. Infine, copia il file nell'archivio usando io. copia.
Estrazione di file dagli archivi Tar
Puoi usare il Nuovo lettore funzione per leggere il contenuto del file di archivio tar. La funzione NewReader accetta un file io. Lettore interfaccia che può essere un file o un buffer di memoria. Restituisce un puntatore a a catrame. Lettore struct.
importare (
"archivio/tar"
"io"
"os"
)funzprincipale() {
// Apre l'archivio tar
file, _ := os. Aprire("mioarchivio.tar")
differire file. Vicino()// Crea un nuovo lettore tar
tarReader := tar. NewReader (file)// Itera sui file nell'archivio
per {
header, err := tarReader. Prossimo()Se errare == io. EOF {
rottura
}
// Estrai il file
outFile, _ := os. Crea (intestazione. Nome)
differire outFile. Vicino()
_, _ = io. Copia (outFile, tarReader)
}
}
IL infinito per il ciclo attraversa l'istanza del lettore tar ed estrae i file copiando ogni file con l'estensione io Pacchetti copia funzione.
Creazione e aggiunta di file agli archivi zip
Puoi creare un nuovo archivio zip con il file Nuovo scrittore funzione del cerniera lampo pacchetto. La funzione NewWriter accetta un'istanza di file e restituisce un writer zip.
importare (
"archivio/zip"
"os"
)funzprincipale() {
// Crea un nuovo file
file, err := os. Creare("archivio.zip")Se errare!= zero {
panico(errare)
}differire file. Vicino()
// Crea un nuovo scrittore zip
zipWriter := zip. NewWriter (file)
differire zipWriter. Vicino()
}
IL zipWriter variabile memorizza un nuovo scrittore istanza che NewWriter restituisce.
Puoi aggiungere file ai tuoi archivi zip con il file Creare funzione dell'istanza di Writer. La funzione Crea accetta il nome del file. Puoi anche usare il Scrivere funzione dell'istanza del file zip per scrivere i dati nei file negli archivi zip.
importare (
"archivio/zip"
"os"
)funzprincipale() {
// Crea nuovi file
file, err := os. Creare("archivio.zip")
file, err = os. Creare("file1.txt")
file, err = os. Creare("file2.txt")Se errare!= zero {
panico(errare)
}differire file. Vicino()
// Crea un nuovo scrittore zip
zipWriter := zip. NewWriter (file)
differire zipWriter. Vicino()// Aggiunge file all'archivio
file1, err := zipWriter. Creare("file1.txt")Se errare!= zero {
panico(errare)
}file2, err := zipWriter. Creare("file2.txt")
Se errare!= zero {
panico(errare)
}
// Scrive i dati nei file nell'archivio
file1.Scrivi([]byte("Ciao mondo!"))
file2.Scrivi([]byte("Addio mondo!"))
fmt. Stampaln("operazione di archiviazione zip completata")
}
La funzione principale inizia usando Creare per creare un nuovo file zip e due file di testo. Quindi crea due writer per aggiungere i due file di testo all'archivio. IL Scrivere La funzione di ogni istanza di file scrive messaggi in ciascuno dei file nell'archivio.
Estrazione di file da archivi zip
Puoi estrarre un file zip esistente leggendolo con l'estensione ApriReader funzione, quindi scorrerne il contenuto e copiare i file con l'estensione io pacchetto.
importare (
"archivio/zip"
"fmt"
"io"
"os"
)funzprincipale() {
// Apre l'archivio
zipReader, err := zip. Lettore aperto("archivio.zip")Se errare!= zero {
panico(errare)
}differire zipReader. Vicino()
// Estrai i file dall'archivio
per _, file := allineare zipReader. File {
zippedFile, err := file. Aprire()Se errare!= zero {
panico(errare)
}differire zippatoFile. Vicino()
// Crea un nuovo file con lo stesso nome del file compresso
extractFile, err := os. Crea (file. Nome)Se errare!= zero {
panico(errare)
}differire estrattoFile. Vicino()
// Copia i dati dal file zippato al nuovo file
_, err = io. Copia (File estratto, File compresso)Se errare!= zero {
panico(errare)
}
fmt. Stampaf("%s\n estratti", file. Nome)
}
}
IL ApriReader la funzione legge gli archivi zip. IL ApriReader La funzione accetta il nome del file zip come argomento e restituisce un'istanza del lettore di file zip. IL for-range ciclo attraversa il contenuto dei file nell'istanza del lettore. Crea un nuovo file con lo stesso nome del file originale e copia il contenuto del file estratto nel nuovo file utilizzando il io. copia funzione.
Decomprimi manualmente o in modo programmatico: dipende da te
La decompressione dei file a livello di codice è utile se si devono decomprimere molti file o archivi. Potresti anche integrare la funzionalità di archiviazione nella tua app principale.
In altri casi, potrebbe essere meglio utilizzare le applicazioni esistenti. Puoi utilizzare app integrate o di terze parti per decomprimere gli archivi su Windows, macOS e Linux.
