func compress(srcPaths []string, outputPath string, useBasePathInZip bool) {
    if len(srcPaths) == 0 {
        return
    }
 
    file, openErr := os.OpenFile(outputPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
    if openErr != nil {
        fmt.Printf("failed to open file %s: %v\n", outputPath, openErr)
        return
    }
    defer file.Close()
 
    zipWriter := zip.NewWriter(file)
    defer zipWriter.Close()
 
    for _, path := range srcPaths {
        
        info, err := os.Stat(path)
        if err != nil {
            fmt.Printf("failed to stat file %s: %v\n", path, err)
            return
        }
 
        if info.IsDir() {
            fmt.Printf("%s is dir...\n", path)
            err = addFilesToDirectory(zipWriter, path, "", useBasePathInZip)
            if err != nil {
                return
            }
 
            continue
        }
 
        fmt.Printf("%s is file...\n", path)
        if err = compressFile(zipWriter, path, useBasePathInZip); err != nil {
            log.Fatalf("add file %s to zip failed: %s", path, err)
        }
    }
}

func addFilesToDirectory(zw *zip.Writer, newDir, baseInZip string, useBasePathInZip bool) error {
    files, err := ioutil.ReadDir(newDir)
    if err != nil {
        return err
    }
 
    fmt.Printf("目錄 %s 下包含 %d 個(gè)對(duì)象.\n", newDir, len(files))
 
    var newBaseInZip string
    for _, fileInfo := range files {
        if useBasePathInZip {
            newBaseInZip = filepath.Join(baseInZip, fileInfo.Name())
        }
 
        newFullPath := filepath.Join(newDir, fileInfo.Name())
 
        fmt.Printf("\tcheck filename=%s, newFullPath=%s, newBaseInZip=%s \n", fileInfo.Name(), newFullPath, newBaseInZip)
 
        // 是目錄，遞歸處理
        if fileInfo.IsDir() {
            if err = addFilesToDirectory(zw, newFullPath, newBaseInZip, useBasePathInZip); err != nil {
                return err
            }
 
            continue
        }
 
        // 處理單個(gè)文件
        if err = compressFile(zw, newFullPath, useBasePathInZip); err != nil {
            return err
        }
    }
 
    return nil
}

func compressFile(zw *zip.Writer, srcFile string, useBasePathInZip bool) error {
    fileToZip, err := os.Open(srcFile)
    if err != nil {
        log.Fatalf("compressFile failed to open %s: %v", srcFile, err)
        return err
    }
    defer fileToZip.Close()
 
    var zipFile io.Writer
 
    if !useBasePathInZip {
        // 獲得源文件FileInfo對(duì)象
        info, err := fileToZip.Stat()
        if err != nil {
            fmt.Printf("failed to open file %s: %v\n", srcFile, err)
            return err
        }
 
        // 創(chuàng)建新的ZIP文件頭，并設(shè)置其內(nèi)部路徑僅為文件名
        header, err := zip.FileInfoHeader(info)
        if err != nil {
            fmt.Printf("failed to create file header for %s: %v\n", srcFile, err)
            return err
        }
 
        fmt.Println("名稱=", header.Name)
 
        // 設(shè)置壓縮后的文件名為源文件名（去掉路徑）
        header.Name = filepath.Base(srcFile)
        
        // 基于主zw流創(chuàng)建該文件的目標(biāo)zip平臺(tái)
        zipFile, err = zw.CreateHeader(header)
        if err != nil {
            return err
        }
    } else {
        zipFile, err = zw.Create(srcFile)
        if err != nil {
            return err
        }
    }
 
    // 將源文件Copy到目標(biāo)zip平臺(tái)
    _, err = io.Copy(zipFile, fileToZip)
 
    fmt.Printf("壓縮 %s 完成 %v\n", srcFile, err)
    return err
}

func main() {
    var srcPaths = []string{"fzip/zipt/a.txt", "fzip/unzip.go"}
    compress(srcPaths, "./a.zip", true)
}

func unzip(unzipFile, unzipDir string) {
    zipReader, _ := zip.OpenReader(unzipFile)
    for i, file := range zipReader.Reader.File {
 
        fmt.Printf("正在壓縮第 %d 個(gè). name=%s Comment=%s, isDir=%v, size=%d.\n", i+1, file.Name, file.Comment, file.FileInfo().IsDir(), file.FileInfo().Size())
 
        func(i int, file *zip.File) {
            zippedFile, err := file.Open()
            if err != nil {
                log.Fatal(err)
            }
            defer zippedFile.Close()
 
            extractedFilePath := filepath.Join(unzipDir, file.Name)
 
            if file.FileInfo().IsDir() {
                _ = os.MkdirAll(extractedFilePath, file.Mode()) // 權(quán)限不變
                fmt.Println("dir Created:", extractedFilePath)
                return
            }
 
            fmt.Println("file extracted: ", file.Name)
 
            func() {
                outputFile, err := os.OpenFile(extractedFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
 
                if err != nil {
                    log.Fatal(err)
                }
                defer outputFile.Close()
 
                _, err = io.Copy(outputFile, zippedFile)
                if err != nil {
                    log.Fatal(err)
                }
            }()
 
        }(i, file)
 
    }
}