méthode de compression Golang

golang est un langage de programmation hautes performances très populaire avec des capacités d'exécution de code relativement puissantes, et sa bibliothèque standard dispose également de nombreuses méthodes pour traiter divers formats de compression de fichiers. Cet article présentera l'utilisation de la méthode de compression Golang.

Tout d'abord, vous devez introduire les packages "compress" et "archive", qui sont des packages liés au traitement de compression dans la bibliothèque standard de Golang. Mais lequel choisir dépend du format de compression.

1. Compression gzip

La méthode de compression gzip dans Golang utilise également le package "compress/gzip" dans la bibliothèque standard.

Ici, nous prenons une chaîne comme exemple de 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())
}

Dans ce code, un cache tampon est d'abord créé, puis un objet gzip.Write est créé et le tampon est passé à cet objet. Ensuite, écrivez la chaîne qui doit être compressée dans cet objet, et enfin fermez l'objet écrivain.

Le résultat de l'impression est : gzip : �▒H-IM0189WVnV-I�HI�J-.�V�R,Q�P.�-NMV-.WVN��O�,�R��S�Q� L ��Kօ_(�з)_/�

2. compression zlib

zlib est un format de compression de données sans perte qui utilise l'algorithme Lempel-Ziv et l'encodage Huffam. Il a un taux de compression relativement élevé et une vitesse de compression relativement rapide, et peut être utilisé dans certains scénarios de transmission et de stockage de données.

La méthode de compression zlib dans golang utilise également le package "compress/zlib" de la bibliothèque standard.

Ici, nous prenons une chaîne comme exemple de 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())
}

Dans ce code, un cache tampon est d'abord créé, puis un objet zlib.Write est créé et le tampon est passé à cet objet. Ensuite, écrivez la chaîne qui doit être compressée dans cet objet, et enfin fermez l'objet écrivain.

Le résultat imprimé est : zlib : pour regrouper plusieurs fichiers ou répertoires dans un seul fichier. Pour effectuer une compression tar dans Golang, vous pouvez utiliser le package "archive/tar" dans la bibliothèque standard

Ici, nous prenons la compression tar d'un. répertoire à titre d'exemple :

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

Dans ce code, le chemin source est d'abord jugé s'il s'agit d'un fichier, il est compressé et enregistré directement s'il s'agit d'un dossier, tous les fichiers qu'il contient sont parcourus et chaque fichier est compressé ; et enregistrés, et tous les fichiers sont empaquetés et compressés

compression zip

zip est un format de fichier d'archive, qui est généralement utilisé pour regrouper un ensemble de fichiers ou de répertoires dans un fichier, et également compresser ces fichiers dans Golang. . Pour la méthode de compression, vous pouvez utiliser le package "archive/zip" dans la bibliothèque standard

Ici, nous prenons comme exemple la compression zip de deux fichiers :

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

   Dans ce code, il parcourt principalement la liste des fichiers qui en ont besoin. à compresser. et ajoutez-les au package compressé un par un.

   Résumé

   golang a des bibliothèques de traitement correspondantes pour différents formats de compression, ce qui facilite grandement le processus de compression de fichiers. compression de fichiers

   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!