Comment utiliser le langage Go pour compresser et décompresser des fichiers ?

Avec le développement continu de la technologie informatique, le traitement des fichiers est devenu un élément essentiel du travail quotidien des utilisateurs d'ordinateurs. À mesure que la quantité de stockage de fichiers continue d’augmenter, la compression des fichiers est devenue une opération très nécessaire. Dans ce processus, l’utilisation du langage Go pour la compression et la décompression de fichiers est devenue un sujet de grande préoccupation.

Le langage Go lui-même fournit une riche bibliothèque standard, qui comprend des fonctions d'outils associées pour le traitement des opérations sur les fichiers. De ce fait, les opérations de compression et de décompression de fichiers utilisant le langage Go sont très simples par rapport aux autres langages. Cet article explique comment utiliser le langage Go pour la compression et la décompression de fichiers.

1. Compression de fichiers

Le langage Go propose deux manières de compresser des fichiers : en utilisant la bibliothèque standard pour la compression de fichiers et en utilisant des bibliothèques tierces pour la compression de fichiers.

1. Utilisez la bibliothèque standard pour la compression de fichiers

Dans la bibliothèque standard de Go, il existe un package "compress", qui contient des implémentations de formats de compression de fichiers courants, notamment gzip, gzip, bz2, lzma, zstd, etc. Les implémentations de ces formats de compression sont regroupées dans différents sous-packages au sein du package « compress ». Différents sous-packages implémentent différents formats de compression. L'implémentation spécifique est la suivante :

package main

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

func main() {
    f, err := os.Create("test.txt.gz")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    gz := gzip.NewWriter(f)
    defer gz.Close()

    _, err = gz.Write([]byte("hello, world!"))
    if err != nil {
        fmt.Println(err)
        return
    }
}

Dans le code ci-dessus, nous avons créé un fichier compressé nommé "test.txt.gz" et y avons écrit la chaîne "hello, world!". L'ensemble du processus utilise la fonction « NewWriter » et la fonction « Write » dans le sous-package gzip. Il convient de noter qu'après avoir utilisé le fichier, vous devez utiliser le mot-clé defer pour fermer le fichier, sinon le descripteur de fichier pourrait fuir.

2. Utilisez des bibliothèques tierces pour la compression de fichiers

Par rapport aux bibliothèques standard, les bibliothèques tierces offrent davantage d'implémentations de formats de compression de fichiers et plus de flexibilité. Les bibliothèques tierces courantes incluent « zip » et « rar ». Ces bibliothèques sont utilisées de la même manière que la bibliothèque standard, sauf que les noms des packages importés sont différents. Prenons l'exemple du package "zip":

package main

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

func main() {
    f, err := os.Create("test.zip")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    zw := zip.NewWriter(f)
    defer zw.Close()

    files := []struct {
        name, body string
    }{
        {"test.txt", "hello, world!"},
    }

    for _, file := range files {
        w, err := zw.Create(file.name)
        if err != nil {
            fmt.Println(err)
            return
        }
        _, err = w.Write([]byte(file.body))
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

Dans le code ci-dessus, nous créons un fichier compressé nommé "test.zip" et y ajoutons un fichier nommé "test.txt", et ajoutons la chaîne "hello, world !" y est écrit. Ce processus est implémenté à l'aide des fonctions "NewWriter" et "Create" du package "zip".

2. Décompression de fichiers

Le langage Go fournit plusieurs packages liés à la compression de fichiers, réalisant ainsi la fonction de décompression de fichiers dans différents formats. Le processus de base de décompression est le suivant :

1. Ouvrez le fichier compressé.
2. Créez le flux de lecture correspondant.
3. Créez le décompresseur correspondant.
4. Écrivez les données lues dans le flux vers le décompresseur et extrayez-les.
5. Fermez les fichiers et autres ressources.
6. Utilisez la bibliothèque standard pour la décompression de fichiers

Le package "compress" de la bibliothèque standard implémente la décompression de plusieurs formats de compression, et la bibliothèque gzip précédente en est un exemple. En d’autres termes, il prend non seulement en charge la compression de fichiers, mais a également la fonction de décompression de fichiers. La méthode spécifique est la suivante :

package main

import (
    "compress/gzip"
    "fmt"
    "io"
    "os"
)

func main() {
    f, err := os.Open("test.txt.gz")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    gz, err := gzip.NewReader(f)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer gz.Close()

    data := make([]byte, 1024)
    for {
        n, err := gz.Read(data)
        if err != nil && err != io.EOF {
            fmt.Println(err)
            return
        }
        if n == 0 {
            break
        }
        fmt.Print(string(data[:n]))
    }
}

Dans le code ci-dessus, nous ouvrons d'abord un fichier compressé nommé "test.txt.gz", puis créons un décompresseur à l'aide de la fonction "NewReader" dans le sous-package gzip. La fonction "Read" lit les données à sortir dans le décompresseur, les affecte à "data" et les sort via la fonction "fmt.Print".

2. Utiliser des bibliothèques tierces pour la décompression de fichiers

L'utilisation de bibliothèques tierces pour la décompression de fichiers est similaire à la compression de fichiers. Il vous suffit d'importer la bibliothèque de décompression correspondant au format de fichier correspondant. Prenons l'exemple du package "zip":

package main

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

func main() {
    r, err := zip.OpenReader("test.zip")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer r.Close()

    for _, f := range r.File {
        rc, err := f.Open()
        if err != nil {
            fmt.Println(err)
            return
        }
        defer rc.Close()

        _, err = io.CopyN(os.Stdout, rc, int64(f.UncompressedSize64))
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

Dans le code ci-dessus, nous utilisons d'abord la fonction "OpenReader" dans le package "zip" pour ouvrir un fichier compressé nommé "test.zip", puis lisons la liste des fichiers dedans. La fonction "Open" renvoie une interface de type "io.ReadCloser", qui représente un fichier ouvert. Nous pouvons utiliser la fonction "Read" de ce type d'interface pour lire les données décompressées, puis les sortir directement via la fonction "io.CopyN".

Résumé

Comme le montre l'introduction ci-dessus, le processus de compression et de décompression de fichiers à l'aide du langage Go est très simple et peut être implémenté à l'aide de bibliothèques standard et de bibliothèques tierces. Bien entendu, il existera également certaines différences de performances et de format entre les fichiers compressés et décompressés, ce qui obligera les développeurs à faire des compromis et à faire des choix. Cependant, de manière générale, le langage Go est très pratique à utiliser et peut répondre à la plupart des besoins applicatifs.

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!