golang compression method

golang is a very popular high-performance programming language with relatively powerful code execution capabilities, and its standard library also has many methods for processing various file compression formats. This article will introduce the use of golang compression method.

First you need to introduce the "compress" and "archive" packages, which are compression processing related packages in the golang standard library. But which one to choose depends on the compression format.

1. gzip compression

The method of gzip compression in golang also uses the "compress/gzip" package in the standard library.

Here we take a string as an example for compression:

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
)

func main() {
    str := "golang gzip test"
    var buf bytes.Buffer
    z := gzip.NewWriter(&buf)
    _, err := z.Write([]byte(str))
    if err != nil {
        panic(err)
    }
    err = z.Close()
    if err != nil {
        panic(err)
    }
    fmt.Println("gzip:", buf.String())
}

In this code, a buffer cache is first created, then a gzip.Write object is created, and the buffer is passed to this object. Then, write the string that needs to be compressed into this object, and finally close the writer object.

The print result is: gzip: �▒H-IM0189WVnV-I�HI�J-.�V�R,Q�P.�-NMV-.WVN��O�,�R��S �Q�L��KՅ_(�з)_/�

2. zlib compression

zlib is a lossless data compression format that uses the Lempel-Ziv algorithm and Huffam coding. It has a relatively high compression rate and a relatively fast compression speed, and can be used in certain data transmission and storage scenarios.

The method of zlib compression in golang also uses the "compress/zlib" package in the standard library.

Here we take a string as an example for compression:

package main

import (
    "bytes"
    "compress/zlib"
    "fmt"
)

func main() {
    str := "golang zlib test"
    var buf bytes.Buffer
    w := zlib.NewWriter(&buf)
    _, err := w.Write([]byte(str))
    if err != nil {
        panic(err)
    }
    err = w.Close()
    if err != nil {
        panic(err)
    }
    fmt.Println("zlib:", buf.String())
}

In this code, a buffer cache is first created, then a zlib.Write object is created, and the buffer is passed to this object. Then, write the string that needs to be compressed into this object, and finally close the writer object.

The print result is: zlib: x�� ��J-.N�(,�QP.I,�M-V-.Q�

3. tar compression

tar is an archive file format that is often used to package multiple files or directories into one file. To perform tar compression in golang, you can use the "archive/tar" package in the standard library.

Here we take tar compression of a directory as an example:

package main

import (
    "archive/tar"
    "fmt"
    "io"
    "os"
)

func tarPath(dst, src string) error {
    info, err := os.Stat(src)
    if err != nil {
        return err 
    }

    // 如果源目录是一个文件，直接对这个文件进行压缩
    if !info.IsDir() {
        srcFile, err := os.Open(src)
        if err != nil {
            return err
        }
        defer srcFile.Close()

        dstFile, err := os.Create(dst + ".tar")
        if err != nil {
            return err
        }
        defer dstFile.Close()

        tarWriter := tar.NewWriter(dstFile)
        defer tarWriter.Close()

        hdr := &tar.Header {
            Name: src,
            Mode: int64(info.Mode()),
            Size: info.Size(),
        }

        if err := tarWriter.WriteHeader(hdr); err != nil {
            return err 
        }

        if _, err := io.Copy(tarWriter, srcFile); err != nil {
            return err
        }

        fmt.Println("tar file created:", dst+".tar")
        return nil 
    }

    // 如果源目录是一个文件夹，先遍历源目录
    files, err := os.ReadDir(src)
    if err != nil {
        return err 
    }

    for _, file := range files {
        fileName := file.Name()

        // 这里需要再次判断是否是一个目录
        if file.IsDir() {
            fmt.Println("skipping directory:", fileName)
            continue
        }

        srcFile, err := os.Open(filepath.Join(src, fileName))
        if err != nil {
            return err
        }
        defer srcFile.Close()

        dstFile, err := os.Create(filepath.Join(dst, fileName) + ".tar")
        if err != nil {
            return err
        }
        defer dstFile.Close()

        tarWriter := tar.NewWriter(dstFile)
        defer tarWriter.Close()

        hdr := &tar.Header {
            Name: fileName,
            Mode: int64(file.Mode()),
            Size: file.Size(),
        }

        if err := tarWriter.WriteHeader(hdr); err != nil {
            return err 
        }

        if _, err := io.Copy(tarWriter, srcFile); err != nil {
            return err
        }

        fmt.Println("tar file created:", filepath.Join(dst, fileName)+".tar")
    }

    return nil 
}

func main() {
    srcPath := "./testdir"
    dstPath := "./"

    err := tarPath(dstPath, srcPath)
    if err != nil {
        fmt.Println(err)
    }
}

In this code, the source path is first judged. If it is a file, it will be compressed and saved directly; if is a folder, then traverse all the files in it and compress and save each file, and package and compress all files.

4. zip Compression

zip Yes An archive file format, which is usually used to package a set of files or directories into one file, and also compress these files. To perform zip compression in golang, you can use "archive/zip" in the standard library package.

Here we take zip compression of two files as an example:

package main

import (
    "archive/zip"
    "fmt"
    "io"
    "os"
)

func zipFiles(dst string, files []string) error {
    newZipFile, err := os.Create(dst + ".zip")
    if err != nil {
        return err
    }
    defer newZipFile.Close()
    zipWriter := zip.NewWriter(newZipFile)
    defer zipWriter.Close()

    for _, file := range files {
        srcFile, err := os.Open(file)
        if err != nil {
            return err
        }
        defer srcFile.Close()

        info, _ := srcFile.Stat()

        header, err := zip.FileInfoHeader(info)
        if err != nil {
            return err
        }
        header.Name = file
        header.Method = zip.Deflate

        writer, err := zipWriter.CreateHeader(header)
        if err != nil {
            return err
        }
        if _, err := io.Copy(writer, srcFile); err != nil {
            return err
        }
    }

    fmt.Println("zip file created:", dst+".zip")
    return nil 
}

func main() {
    files := []string{"test.txt", "test1.txt"}
    dstPath := "./"

    err := zipFiles(dstPath, files)
    if err != nil {
        fmt.Println(err)
    }
}

In this code, it mainly traverses the list of files that need to be compressed and adds them one by one to in the compressed package.

Summary

golang has corresponding processing libraries for various compression formats, which greatly facilitates the file compression processing process. Here are only a few popular ones. How to deal with file compression methods.

The above is the detailed content of golang compression method. For more information, please follow other related articles on the PHP Chinese website!