Golang-Komprimierungsmethode

golang ist eine sehr beliebte Hochleistungsprogrammiersprache mit relativ leistungsstarken Codeausführungsfunktionen, und ihre Standardbibliothek verfügt auch über viele Methoden zur Verarbeitung verschiedener Dateikomprimierungsformate. In diesem Artikel wird die Verwendung der Golang-Komprimierungsmethode vorgestellt.

Zuerst müssen Sie die Pakete „compress“ und „archive“ einführen, bei denen es sich um Pakete für die Komprimierungsverarbeitung in der Golang-Standardbibliothek handelt. Welches Sie wählen sollten, hängt jedoch vom Komprimierungsformat ab.

1. gzip-Komprimierung

Die Methode der gzip-Komprimierung in Golang verwendet auch das Paket „compress/gzip“ in der Standardbibliothek.

Hier nehmen wir einen String als Beispiel für die Komprimierung:

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

In diesem Code wird zuerst ein Puffercache erstellt, dann ein gzip.Write-Objekt erstellt und der Puffer an dieses Objekt übergeben. Schreiben Sie dann die Zeichenfolge, die komprimiert werden muss, in dieses Objekt und schließen Sie schließlich das Writer-Objekt.

Das Druckergebnis ist: gzip: „▒H-IM0189WVnV-I�HI�J-.�V�R,Q�P.�-NMV-.WVN��O�,�R��S�Q� L ��Kօ_(�з)_/�

2. zlib-Komprimierung

zlib ist ein verlustfreies Datenkomprimierungsformat, das den Lempel-Ziv-Algorithmus und die Huffam-Kodierung verwendet. Es verfügt über eine relativ hohe Komprimierungsrate und eine relativ hohe Komprimierungsgeschwindigkeit und kann in bestimmten Datenübertragungs- und Speicherszenarien verwendet werden.

Die Methode der zlib-Komprimierung in Golang verwendet auch das Paket „compress/zlib“ in der Standardbibliothek.

Hier nehmen wir einen String als Beispiel für die Komprimierung:

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

In diesem Code wird zuerst ein Puffercache erstellt, dann ein zlib.Write-Objekt erstellt und der Puffer an dieses Objekt übergeben. Schreiben Sie dann die Zeichenfolge, die komprimiert werden muss, in dieses Objekt und schließen Sie schließlich das Writer-Objekt.

Das gedruckte Ergebnis ist: zlib: Um mehrere Dateien oder Verzeichnisse in einer Datei zu packen, können Sie das Paket „archive/tar“ in der Standardbibliothek verwenden.

Hier nehmen wir die Tar-Komprimierung von a Verzeichnis als Beispiel:

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

In diesem Code wird zunächst der Quellpfad beurteilt. Wenn es sich um eine Datei handelt, wird sie direkt gespeichert. Wenn es sich um einen Ordner handelt, werden alle darin enthaltenen Dateien durchlaufen und jede Datei wird komprimiert und gespeichert, und alle Dateien werden gepackt und komprimiert.

zip-Komprimierung

zip ist ein Archivdateiformat, das normalerweise verwendet wird, um eine Reihe von Dateien oder Verzeichnissen in eine Datei zu packen und diese Dateien auch in Golang zu komprimieren . Als Komprimierungsmethode können Sie das Paket „archive/zip“ in der Standardbibliothek verwenden.

Hier nehmen wir die Zip-Komprimierung von zwei Dateien:

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

   In diesem Code wird hauptsächlich die Liste der benötigten Dateien durchlaufen

   Zusammenfassung

   golang verfügt über entsprechende Verarbeitungsbibliotheken für verschiedene Komprimierungsformate, was den Dateikomprimierungsprozess erheblich erleichtert Dateikomprimierung

   Das obige ist der detaillierte Inhalt vonGolang-Komprimierungsmethode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!