Cara melakukan pemampatan di Golang dan sediakan beberapa helah pemampatan

Pustaka mampatan (mampat) yang disertakan dengan bahasa Go menyediakan pelbagai fungsi mampatan dan penyahmampatan, yang boleh digunakan untuk menukar maklumat daripada satu bentuk kepada bentuk lain, menjadikannya lebih sesuai untuk penyimpanan atau penghantaran. Dalam artikel ini, kami akan menyelidiki cara memampatkan di Golang dan menyediakan beberapa teknik mampatan untuk membantu anda menggunakan pustaka mampatan Golang dengan lebih baik.

1. mampatan gzip

Gzip ialah format mampatan berdasarkan algoritma DEFLATE, yang boleh memampatkan data dengan menggantikan rentetan berulang dalam data input. Pustaka mampatan Gzip dilaksanakan dalam pustaka standard bahasa Go dan melaksanakan algoritma mampatan Gzip. Untuk menggunakannya, anda perlu mengimport pakej mampatan dan membuat instantiate menggunakan fungsi GzipWriter, kemudian anda boleh menggunakan fungsi Write() untuk menulis data ke dalam buffer gzip, dan akhirnya gunakan fungsi Flush() untuk menulis data dalam penimbal Flush ke memori atau cakera.

Contoh berikut boleh digunakan untuk menggambarkan helah mampatan gzip:

package main

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

func main() {
    var b strings.Builder
    w := gzip.NewWriter(&b)
    defer w.Close()

    data := []byte("Hello, World!")
    _, err := w.Write(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Compressed data: %q\n", b.String())
}

Output:

Compressed data: "\x1f\x8b\x08\x00\x00\x09\x6e\x88\xff\x4b\xcc\x4d\x55\x70\x76\x.00\x04\x00\x00\xff\xff\x48\x65\x6c\x6c\x6f\x2c\x20\x57\x6f\x72\x6c\x64\x21\x2.00\x00\x00\x00"

Dalam contoh di atas, kami lulus gzip.NewWriter () fungsi Kaitkan aliran keluaran dengan pemampat dan gunakan pernyataan tangguh untuk menutup penulis dengan malas untuk memastikan semua data dalam penimbal ditulis. Kami juga menulis rentetan pada penimbal mampatan dan mencetak data termampat pada penghujungnya.

2. mampatan zlib

mampatan zlib ialah proses menukar data input kepada data keluaran yang lebih kecil dengan kandungan data yang sama. Ia berdasarkan algoritma DEFLATE dan biasanya digunakan untuk memampatkan kandungan web dan penghantaran data kerana ia memastikan kecekapan penghantaran yang optimum. zlib menyediakan jenis zlib.Writer untuk memampatkan data ke dalam format zlib. Anda boleh menggunakan contoh berikut untuk memahami cara untuk memampatkan zlib dalam Go:

package main

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

func main() {
    var b bytes.Buffer

    w := zlib.NewWriter(&b)
    defer w.Close()

    data := []byte("Hello, World!")
    _, err := w.Write(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Compressed data: %q\n", b.Bytes())
}

Output:

Compressed data: "\x78\x9c\x4b\xcb\xcf\x4f\x2c\x4b\x2d\x01\x00\x12\x1c\x06\xc8"

Dalam contoh di atas, kami mencipta bait.Buffer buffer dan menggunakan zlib Fungsi .NewWriter mengaitkannya dengan pemampat. Data akan dimampatkan menjadi penimbal dan pada akhirnya data yang dimampatkan akan dicetak ke terminal.

3. mampatan leper

pakej mampatan leper ialah salah satu pakej mampatan Golang sendiri, menyokong bait tunggal, bacaan 1-bit dan 2-bit, 3-bit dan 4 Bit baca pengekodan. Sudah tentu, kaedah pemampatan ini hanya sesuai untuk data dan teks mudah, dsb., kerana ia tidak dapat mengendalikan struktur data yang kompleks. Anda boleh menggunakan contoh berikut untuk melihat cara menggunakan Golang flate compression:

package main

import (
    "compress/flate"
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    w, err := flate.NewWriter(&b, flate.DefaultCompression)
    if err != nil {
        panic(err)
    }
    defer w.Close()

    data := []byte("Hello, World!")
    _, err = w.Write(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Compressed data: %q\n", b.String())
}

Output:

Compressed data: "\x01\x9d\x8c\x0f\x4c\x4f\x4e\xce\xcf\x49\xcd\x4b\xcd\xaf.00\x00\x00\xff\xff\x48\x65\x6c\x6c\x6f\x2,20\x57\x6f\x72\x6c\x64\x21\x2.00\x00"

Dalam contoh di atas, kami mencipta string writer dan menggunakan The flate. Fungsi NewWriter() mengaitkannya dengan pemampat. Apabila memampatkan data, kita perlu menentukan tahap mampatan. DefaultCompression ialah tahap mampatan yang paling biasa digunakan yang kami tentukan, menunjukkan mampatan optimum. Kami mencetak data termampat melalui kod.

4. mampatan pantas

Snappy ialah algoritma pemampatan dan penyahmampatan data pantas daripada Google Ia biasanya digunakan untuk memproses data yang tidak perlu disimpan pada pemampatan tinggi nisbah. Pakej pantas bahasa Go melaksanakan algoritma pemampatan ini dan menyediakan fungsi pemampatan dan penyahmampatan yang berkesan. Anda boleh menggunakan contoh berikut untuk memahami cara menggunakan snappy dalam Go:

package main

import (
    "fmt"
    "github.com/golang/snappy"
)

func main() {
    data := []byte("Hello, World!")
    compressed := snappy.Encode(nil, data)

    fmt.Printf("Compressed data: %q\n", compressed)

    uncompressed, err := snappy.Decode(nil, compressed)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Uncompressed data: %q\n", uncompressed)
}

Output:

Compressed data: "\x0cHello, World!"
Uncompressed data: "Hello, World!"

Dalam contoh di atas, kami menggunakan fungsi snappy.Encode() untuk menukar "Hello , World!" rentetan dimampatkan dan kemudian dinyahmampat menggunakan fungsi snappy.Decode().

Ringkasan

Artikel ini menyediakan contoh penggunaan perpustakaan mampatan mampat untuk melaksanakan empat algoritma mampatan dalam Golang. gzip dan zlib ialah algoritma pemampatan yang paling biasa digunakan dan digunakan secara meluas dalam pemindahan data dan aplikasi rangkaian. Snappy biasanya digunakan dalam senario dengan keperluan prestasi yang sangat tinggi untuk pemampatan data, manakala flate kurang biasa digunakan. Dalam mana-mana kes, kita boleh memilih algoritma pemampatan yang paling sesuai dan konfigurasinya berdasarkan situasi sebenar untuk meningkatkan kebolehskalaan dan prestasi aplikasi.

Atas ialah kandungan terperinci Cara melakukan pemampatan di Golang dan sediakan beberapa helah pemampatan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!