Comment faire de la compression dans Golang et mettre en place quelques astuces de compression

La bibliothèque de compression (compress) fournie avec le langage Go fournit une variété de fonctions de compression et de décompression, qui peuvent être utilisées pour convertir des informations d'une forme à une autre, les rendant plus adaptées au stockage ou à la transmission. Dans cet article, nous verrons comment compresser dans Golang et mettrons en place quelques techniques de compression pour vous aider à mieux utiliser la bibliothèque de compression Golang.

1. compression gzip

Gzip est un format de compression basé sur l'algorithme DEFLATE, qui peut compresser les données en remplaçant les chaînes répétées dans les données d'entrée. La bibliothèque de compression Gzip est implémentée dans la bibliothèque standard du langage Go et implémente l'algorithme de compression Gzip. Pour l'utiliser, vous devez importer le package de compression et l'instancier à l'aide de la fonction GzipWriter. Vous pouvez ensuite utiliser la fonction Write() pour écrire les données dans le tampon gzip, et enfin utiliser la fonction Flush() pour écrire les données. le tampon. Vider la mémoire ou le disque.

L'astuce de compression gzip peut être illustrée à l'aide de l'exemple suivant :

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

Sortie :

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"

Dans l'exemple ci-dessus, nous associons le flux de sortie au compresseur via la fonction gzip.NewWriter() et fermons paresseusement l'écriture en utilisant le defer instruction buffer pour garantir que toutes les données du tampon sont écrites. Nous écrivons également une chaîne dans le tampon de compression et imprimons les données compressées à la fin.

2. compression zlib

La compression zlib est le processus de conversion des données d'entrée en données de sortie plus petites avec le même contenu de données. Il est basé sur l'algorithme DEFLATE et est couramment utilisé pour compresser le contenu Web et la transmission de données car il garantit une efficacité de transmission optimale. zlib fournit le type zlib.Writer pour compresser les données au format zlib. Vous pouvez utiliser l'exemple suivant pour comprendre comment compresser zlib dans 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())
}

Sortie :

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

Dans l'exemple ci-dessus, nous créons un bytes.Buffer et l'associons au compresseur à l'aide de la fonction zlib.NewWriter. Les données seront compressées dans un tampon et à la fin les données compressées seront imprimées sur le terminal.

3. flate compression

flate compression package est l'un des propres packages de compression de Golang. Il prend en charge les méthodes d'encodage de lecture sur un octet, 1 bit et 2 bits, 3 bits et 4 bits. Bien entendu, cette méthode de compression ne convient qu’aux données simples, au texte, etc., car elle ne peut pas gérer des structures de données complexes. Vous pouvez voir comment utiliser la compression Golang flate en utilisant l'exemple suivant :

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

Sortie :

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"

Dans l'exemple ci-dessus, nous avons créé un rédacteur de chaînes et l'avons associé au compresseur à l'aide de la fonction flate.NewWriter() Union. Lors de la compression des données, nous devons spécifier le niveau de compression. DefaultCompression est le niveau de compression le plus couramment utilisé que nous spécifions, indiquant une compression optimale. Nous imprimons les données compressées via du code.

4. snappy compression

Snappy est un algorithme de compression et de décompression de données rapide de Google, qui est généralement utilisé pour traiter des données qui n'ont pas besoin d'être stockées à un taux de compression élevé. Le package Snappy du langage Go implémente cet algorithme de compression et fournit des fonctions de compression et de décompression efficaces. Vous pouvez utiliser l'exemple suivant pour comprendre comment utiliser snappy dans 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)
}

Sortie :

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

Dans l'exemple ci-dessus, nous utilisons la fonction snappy.Encode() pour compresser la chaîne "Hello, World!" snappy. La fonction Decode() le décompresse.

Résumé

Cet article fournit des exemples d'utilisation de la bibliothèque de compression compress pour implémenter quatre algorithmes de compression dans Golang. gzip et zlib sont les algorithmes de compression les plus couramment utilisés et sont largement utilisés dans les applications de transfert de données et de réseau. snappy est généralement utilisé dans des scénarios exigeant des performances très élevées pour la compression des données, tandis que flate est moins couramment utilisé. Dans les deux cas, nous pouvons choisir l’algorithme de compression le plus approprié et sa configuration en fonction de la situation réelle pour améliorer l’évolutivité et les performances de l’application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!