golang zip garbled code

When using Golang for file compression, you may encounter the problem of garbled compressed file names. The reason for this problem is that Golang's Zip library does not handle Chinese characters well when compressing files.

Generally speaking, Chinese characters are stored in Unicode character encoding in computers. When files in Zip format store file names, they use an encoding method called "CP437" (also known as "MS-DOS" encoding in Windows). This encoding method only supports a small number of character sets. , does not include Chinese characters, so when the Zip compressed file contains Chinese characters, garbled characters will appear.

To solve this problem, we need to convert the file name from Unicode encoding to CP437 encoding when compressing the file. Golang provides a built-in function golang.org/x/text/encoding/simplifiedchinese.GBK, which can convert UTF-8 encoded strings to GBK encoding.

The following is a sample code that can use GBK encoding when compressing files:

package main

import (
    "archive/zip"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "golang.org/x/text/encoding/simplifiedchinese"
)

func main() {
    fmt.Println("Starting the application...")
    inputDir := "input_dir"
    outputFile := "output.zip"
    err := Zip(inputDir, outputFile)
    if err != nil {
        panic(err)
    }
    fmt.Println("Output file created successfully!")
}

// Zip function compress a folder to zip file
func Zip(source, target string) error {
    targetfile, err := os.Create(target)
    if err != nil {
        return err
    }
    defer targetfile.Close()

    zipWriter := zip.NewWriter(targetfile)
    defer zipWriter.Close()

    filepath.Walk(source, func(path string, info os.FileInfo, err error) error {
        if info.IsDir() {
            return nil
        }
        if err != nil {
            return err
        }

        filename := info.Name()
        gbkFilename, err := simplifiedchinese.GBK.NewEncoder().String(filename)
        if err != nil {
            return err
        }

        file, err := os.Open(path)
        if err != nil {
            return err
        }

        defer file.Close()

        zipfile, err := zipWriter.Create(gbkFilename)
        if err != nil {
            return err
        }

        _, err = io.Copy(zipfile, file)
        if err != nil {
            return err
        }
        return nil
    })

    return nil
}

In the above code, we used the filepath.Walk method to traverse the folder All files in and use the GBK.NewEncoder().String() method to convert the file name from UTF-8 encoding to GBK encoding. We then use the converted filename to create the Zip file entry in the zipWriter.Create method.

In the above example code, we use Simplified Chinese encoding. If you need to use Traditional Chinese encoding or other encoding methods, please modify the corresponding encoding method.

Summary

When compressing Zip files in Golang, you may encounter the problem of garbled file names. To solve this problem, you need to convert the file name from Unicode encoding to the encoding used by the Zip file when compressing the file. The above sample code demonstrates how to use GBK encoding to solve the problem of garbled Zip file names.

The above is the detailed content of golang zip garbled code. For more information, please follow other related articles on the PHP Chinese website!