kaedah mampatan golang

Golang ialah bahasa pengaturcaraan berprestasi tinggi yang sangat popular dengan keupayaan pelaksanaan kod yang agak berkuasa, dan perpustakaan standardnya juga mempunyai banyak kaedah untuk memproses pelbagai format pemampatan fail. Artikel ini akan memperkenalkan penggunaan kaedah mampatan golang.

Mula-mula anda perlu memperkenalkan pakej "compress" dan "archive", yang kedua-duanya merupakan pakej berkaitan pemprosesan mampatan dalam pustaka standard golang. Tetapi yang mana satu untuk dipilih bergantung pada format mampatan.

1. mampatan gzip

Kaedah pemampatan gzip dalam golang juga menggunakan pakej "compress/gzip" dalam perpustakaan standard.

Di sini kita mengambil rentetan sebagai contoh untuk pemampatan:

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())
}

Dalam kod ini, cache penimbal dibuat pertama kali, kemudian objek gzip.Write dicipta dan penimbal dihantar ke objek ini. Kemudian, tulis rentetan yang perlu dimampatkan ke dalam objek ini, dan akhirnya tutup objek penulis.

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

2. mampatan zlib

zlib ialah format pemampatan data tanpa kehilangan yang menggunakan algoritma Lempel-Ziv dan Pengekodan Huffam. Ia mempunyai kadar mampatan yang agak tinggi dan kelajuan mampatan yang agak pantas, dan boleh digunakan dalam senario penghantaran dan penyimpanan data tertentu.

Kaedah pemampatan zlib dalam golang juga menggunakan pakej "compress/zlib" dalam perpustakaan standard.

Di sini kita mengambil rentetan sebagai contoh untuk pemampatan:

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())
}

Dalam kod ini, cache penimbal dibuat pertama kali, kemudian objek zlib.Write dicipta dan penimbal dihantar ke objek ini. Kemudian, tulis rentetan yang perlu dimampatkan ke dalam objek ini, dan akhirnya tutup objek penulis.

Hasil cetakan ialah: zlib: x��+��J-.N�(,�QP.I,�M-V-.Q�

3. mampatan tar

tar ialah format fail arkib yang sering digunakan untuk membungkus berbilang fail atau direktori ke dalam satu fail Untuk melakukan pemampatan tar dalam golang, anda boleh menggunakan pakej "archive/tar" dalam pustaka standard 🎜>

Di sini kita mengambil mampatan tar sebagai contoh:

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)
    }
}

dalam kod ini, laluan sumber pertama kali dinilai ialah folder, melintasi semua fail di dalamnya dan memampatkan serta menyimpan setiap fail, dan membungkus dan memampatkan semua fail

zip

zip ini adalah format fail arkib yang biasanya digunakan untuk membungkus set fail atau direktori ke dalam satu fail, dan juga memampatkan fail ini untuk pemampatan zip dalam golang, anda boleh menggunakan "arkib/zip" dalam pustaka standard.

Di sini kami mengambil pemampatan zip dua fail sebagai contoh:

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)
    }
}

Dalam kod ini, ia merentasi senarai fail yang perlu dimampatkan dan menambahkannya satu demi satu ke dalam pakej dimampatkan 🎜>Ringkasan

golang mempunyai perpustakaan pemprosesan yang sepadan untuk pelbagai format pemampatan, yang sangat memudahkan proses pemampatan fail Berikut adalah beberapa cara untuk menangani kaedah pemampatan fail yang popular

Atas ialah kandungan terperinci kaedah mampatan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!