Come comprimere e decomprimere i file in Golang
Gli algoritmi Gzip e Zlib sono comunemente usati per comprimere e decomprimere i file. Gzip viene utilizzato principalmente per comprimere singoli file, mentre Zlib comprime principalmente flussi di dati. Gli algoritmi utilizzano l’algoritmo di compressione Deflate per la compressione, sebbene Gzip fornisca funzionalità aggiuntive tra cui il controllo degli errori e i metadati dei file.
Gzip ha fornito rapporti di compressione migliori rispetto a Zlib. Tuttavia, Gzip richiede più potenza di elaborazione per comprimere e decomprimere i dati. Nella maggior parte dei casi, dovresti usare Gzip per comprimere i file e Zlib per comprimere i flussi di dati.
Go fornisce la funzionalità per la compressione dei dati, inclusi i file tramite il pacchetto compress .
Il pacchetto Compress
Il pacchetto compress supporta la compressione dei dati attraverso i pacchetti compress/gzip e compress/zlib , tra le altre funzionalità.
Il pacchetto gzip supporta la compressione e la decompressione dei dati in formato file gzip, comprese le operazioni di lettura e scrittura come specificato in RFC 1952 . Mentre il pacchetto zlib aiuta a comprimere e decomprimere i dati nel formato zlib.
Puoi importare gzip e zlib dal pacchetto compress usando la parola chiave import .
import (
"compress/gzip" // import gzip
"compress/zlib" // import zlib
)
Comprimere e decomprimere i file con Gzip
Gzip è un formato di file e un’applicazione software per la compressione e la decompressione dei file. Gzip utilizza l’algoritmo della catena Lempel-Ziv-Markov (LZ77) per comprimere i dati e l’algoritmo viene spesso utilizzato per comprimere file di testo, come file HTML, CSS o JavaScript.
Il processo di compressione dei file con il pacchetto gzip è semplice e intuitivo. Dovrai aprire il file, creare un file compresso con gzip, creare un writer gzip e copiare il contenuto del file originale nel writer gzip prima dell’operazione di svuotamento che garantisce il completamento del processo di scrittura.
Esegui questo comando bash nel terminale della tua directory di lavoro su sistemi Unix per creare un file di testo di esempio e quindi inserire il testo nel file.
// creates a text file.
touch example.txt
// pipes the string to the file
echo 'Hello, world!' > example.txt}
Dopo aver creato il file e inserito il testo, puoi importare i pacchetti gzip , io e os per l’operazione di compressione.
Ecco come puoi usare il pacchetto compress/gzip per comprimere un file di testo.
import (
"compress/gzip"
"io"
"os"
)
func main() {
// Open the original file
originalFile, err: = os.Open("example.txt")
if err! = nil {
panic(err)
}
defer originalFile.Close()
// Create a new gzipped file
gzippedFile, err: = os.Create("example.txt.gz")
if err! = nil {
panic(err)
}
defer gzippedFile.Close()
// Create a new gzip writer
gzipWriter: = gzip.NewWriter(gzippedFile)
defer gzipWriter.Close()
// Copy the contents of the original file to the gzip writer
_, err = io.Copy(gzipWriter, originalFile)
if err! = nil {
panic(err)
}
// Flush the gzip writer to ensure all data is written
gzipWriter.Flush()
}
La funzione Open del pacchetto os apre il file di testo e la funzione Close chiude il file con un’istruzione defer . La funzione Create crea un file compresso con gzip e la funzione NewWriter del pacchetto gzip scrive il contenuto del file di testo nel file gzip utilizzando la funzione Copy del pacchetto io .
Il metodo Flush dell’istanza gzipWriter scarica il writer gzip una volta che tutti i dati sono disponibili nel file compresso.
È possibile recuperare il file originale da un file gzippato tramite un processo di decompressione. Il processo di decompressione di un file è simile; aprirai il file e creerai un lettore di file gzip, quindi creerai un nuovo file per contenere i dati non compressi prima di copiare il contenuto nel nuovo file.
import (
"compress/gzip"
"io"
"os"
)
func main() {
// Open the gzipped file
gzippedFile, err: = os.Open("example.txt.gz")
if err! = nil {
panic(err)
}
defer gzippedFile.Close()
// Create a new gzip reader
gzipReader, err: = gzip.NewReader(gzippedFile)
defer gzipReader.Close()
// Create a new file to hold the uncompressed data
uncompressedFile, err: = os.Create("example.txt")
if err! = nil {
panic(err)
}
defer uncompressedFile.Close()
// Copy the contents of the gzip reader to the new file
_, err = io.Copy(uncompressedFile, gzipReader)
if err! = nil {
panic(err)
}
}
La funzione Open del pacchetto os apre il file compresso con gzip e la funzione NewReader del pacchetto gzip legge il file compresso. La funzione Create del pacchetto os crea un nuovo file di testo. La funzione Copy copia il contenuto di gzipReader in uncompressedFile .
Comprimere e decomprimere i dati con Zlib
Zlib è una libreria per la compressione e decompressione dei dati; la libreria utilizza anche l’algoritmo LZ77. Zlib è scritto in C ed è ampiamente utilizzato come base per altre librerie e software di compressione. A differenza di gzip , zlib è una libreria e zlib non include un formato di file. Tuttavia, viene spesso utilizzato per comprimere i dati archiviati in formati contenitore, come PNG o HTTP.
Il processo di compressione con zlib è lo stesso di gzip. Creerai un file zlib, configurerai un writer, aprirai il file originale e copierai il contenuto nel file compresso.
import (
"compress/zlib"
"io"
"os"
)
func main() {
// Create a new file "example.zlib"
file, err: = os.Create("example.zlib")
// If error occurs, panic and stop the program
if err! = nil {
panic(err)
}
// Ensure that the file is closed after the function returns
defer file.Close()
// Create a new zlib writer with the best compression level
writer, err: = zlib.NewWriterLevel(file, zlib.BestCompression)
// If error occurs, panic and stop the program
if err! = nil {
panic(err)
}
// Ensure that the writer is closed after the function returns
defer writer.Close()
// Open the input file "example.txt"
inputFile, err: = os.Open("example.txt")
// If error occurs, panic and stop the program
if err! = nil {
panic(err)
}
// Ensure that the input file is closed after the function returns
defer inputFile.Close()
// Copy the contents of the input file to the writer
io.Copy(writer, inputFile)
}
Il metodo Create crea il file zlib e la funzione NewWriterLevel crea un writer per il file con l’opzione specificata (in questo caso, l’ opzione BestCompression ). Il metodo Open del pacchetto os apre il file di testo e la funzione Copy del pacchetto io copia il contenuto del file di testo nel file zlib nel processo di compressione.
Per decomprimere il file zlib, dovrai aprire il file compresso, creare un nuovo lettore zlib e infine copiare il contenuto del lettore nell’output standard.
import (
"compress/zlib"
"io"
"os"
)
func main() {
// Open the compressed file "compressed_file.zlib"
file, err: = os.Open("compressed_file.zlib")
// If error occurs, panic and stop the program
if err! = nil {
panic(err)
}
// Ensure that the file is closed after the function returns
defer file.Close()
// Create a new zlib reader for the compressed file
reader, err: = zlib.NewReader(file)
// If error occurs, panic and stop the program
if err! = nil {
panic(err)
}
// Ensure that the reader is closed after the function returns
defer reader.Close()
// Copy the contents of the reader to the standard output
io.Copy(os.Stdout, reader)
}
La funzione main apre il file zlib con la funzione Open del pacchetto os e la funzione NewReader del pacchetto zlib legge il file zlib in un’istanza del lettore. Il metodo Copy del pacchetto io copia il contenuto dal lettore allo standard output (in questo caso, la console).
Usa questi strumenti per la compressione dei file
Scrivere codice per la compressione dei file è utile per automatizzare le attività e comprimere diversi file. Se hai solo bisogno di comprimere pochi file, puoi ricorrere all’utilizzo di applicazioni come WinRar, WinZip, Express Zip e Bandizip.
Lascia un commento