¿Cómo comprimir y descomprimir un archivo usando lz4?

Hola, encontramos la solución a tu pregunta, deslízate y la obtendrás aquí.

Creo que el ejemplo de golpe debería dirigirte a la dirección correcta. Es el ejemplo más simple de cómo comprimir y descomprimir usando github.com/pierrec/lz4 paquete.

//compress project main.go
package main

import "fmt"
import "github.com/pierrec/lz4"

var fileContent = `CompressBlock compresses the source buffer starting at soffet into the destination one.
This is the fast version of LZ4 compression and also the default one.
The size of the compressed data is returned. If it is 0 and no error, then the data is incompressible.
An error is returned if the destination buffer is too small.`

func main() 
    toCompress := []byte(fileContent)
    compressed := make([]byte, len(toCompress))

    //compress
    l, err := lz4.CompressBlock(toCompress, compressed, 0)
    if err != nil 
        panic(err)
    
    fmt.Println("compressed Data:", string(compressed[:l]))

    //decompress
    decompressed := make([]byte, len(toCompress))
    l, err = lz4.UncompressBlock(compressed[:l], decompressed, 0)
    if err != nil 
        panic(err)
    
    fmt.Println("ndecompressed Data:", string(decompressed[:l]))

Usando el paquete bufio puedes (des)comprimir archivos sin sorber todo su contenido en tu memoria de una sola vez.

En efecto, esto le permite (des)comprimir archivos más grandes que la memoria disponible para el sistema, lo que puede o no ser relevante para sus circunstancias específicas.

Si esto es relevante, puede encontrar un ejemplo de trabajo aquí:

package main

import (
    "bufio"
    "io"
    "os"

    "github.com/pierrec/lz4"
)

// Compress a file, then decompress it again!
func main() 
    compress("./compress-me.txt", "./compressed.txt")
    decompress("./compressed.txt", "./decompressed.txt")


func compress(inputFile, outputFile string) 
    // open input file
    fin, err := os.Open(inputFile)
    if err != nil 
        panic(err)
    
    defer func() 
        if err := fin.Close(); err != nil 
            panic(err)
        
    ()
    // make a read buffer
    r := bufio.NewReader(fin)

    // open output file
    fout, err := os.Create(outputFile)
    if err != nil 
        panic(err)
    
    defer func() 
        if err := fout.Close(); err != nil 
            panic(err)
        
    ()
    // make an lz4 write buffer
    w := lz4.NewWriter(fout)

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for 
        // read a chunk
        n, err := r.Read(buf)
        if err != nil && err != io.EOF 
            panic(err)
        
        if n == 0 
            break
        

        // write a chunk
        if _, err := w.Write(buf[:n]); err != nil 
            panic(err)
        
    

    if err = w.Flush(); err != nil 
        panic(err)
    


func decompress(inputFile, outputFile string) 
    // open input file
    fin, err := os.Open(inputFile)
    if err != nil 
        panic(err)
    
    defer func() 
        if err := fin.Close(); err != nil 
            panic(err)
        
    ()

    // make an lz4 read buffer
    r := lz4.NewReader(fin)

    // open output file
    fout, err := os.Create(outputFile)
    if err != nil 
        panic(err)
    
    defer func() 
        if err := fout.Close(); err != nil 
            panic(err)
        
    ()

    // make a write buffer
    w := bufio.NewWriter(fout)

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for 
        // read a chunk
        n, err := r.Read(buf)
        if err != nil && err != io.EOF 
            panic(err)
        
        if n == 0 
            break
        

        // write a chunk
        if _, err := w.Write(buf[:n]); err != nil 
            panic(err)
        
    

    if err = w.Flush(); err != nil 
        panic(err)
    

Eres capaz de confirmar nuestro cometido dejando un comentario y valorándolo te lo agradecemos.

---

---

Utiliza Nuestro Buscador