go语言path/filepath包之Walk源码解析

//这里的参数root可以是文件名也可以是目录名;walkFn是自定义的函数
func Walk(root string, walkFn WalkFunc) error {

    //获取root的描述信息
    info, err := os.Lstat(root)
    if err != nil {
        //如果获取描述信息发生错误,返回err由定义的walkFn函数处理
        err = walkFn(root, nil, err)
    } else {
        //调用walk(root, info, walkFn)函数进行递归遍历root
        err = walk(root, info, walkFn)
    }
    if err == SkipDir {
        return nil
    }
    return err
}

func walk(path string, info os.FileInfo, walkFn WalkFunc) error {

    //调用定义的walkFn自定义函数处理
    err := walkFn(path, info, nil)
    if err != nil {
        //返回错误，且该目录可以跳过
        if info.IsDir() && err == SkipDir {
            return nil
        }
        return err
    }

    //如果是文件,则遍历下一个
    if !info.IsDir() {
        return nil
    }

    //读取该path下的所有目录和文件
    names, err := readDirNames(path)
    if err != nil {
        //发生错误，调用自定义函数处理
        return walkFn(path, info, err)
    }

    //遍历文件和目录列表
    for _, name := range names {
        //路径path/name
        filename := Join(path, name)
        //获取该文件或者目录信息
        fileInfo, err := lstat(filename)
        if err != nil {
            //发生错误，调用自定义函数处理
            if err := walkFn(filename, fileInfo, err); err != nil && err != SkipDir {
                return err
            }
        } else {
            //这里递归调用,获取root下各级文件和目录信息,在自定义函数walkFn里做处理
            err = walk(filename, fileInfo, walkFn)
            if err != nil {
                //遍历文件发生错误或者目录发生错误且不能跳过,则返回err
                if !fileInfo.IsDir() || err != SkipDir {
                    return err
                }
            }
        }
    }
    return nil
}

func main() {
    //oldFileName可以是文件或者目录
    oldFileName := "root.log"

    currentTime := time.Now()

    //获取s
    mSecond := fmt.Sprintf("%03d", currentTime.Nanosecond() / 1e6)

    //zip文件名
    zipFileName := strings.Split(oldFileName, ".")[0] + "_" + currentTime.Format("20060102150405") + mSecond + ".zip"

    //压缩文件
    zipFile(oldFileName, zipFileName)
}

func zipFile(source, target string) error{

    //创建目标zip文件
    zipFile , err := os.Create(target)

    if err != nil {
        fmt.Println(err)
        return err
    }

    //关闭文件
    defer zipFile.Close()

    //创建一个写zip的writer
    archive := zip.NewWriter(zipFile)

    defer archive.Close()

    return filepath.Walk(source, func(path string, info os.FileInfo, err error) error {

        if err != nil {
            return err
        }

        //将文件或者目录信息转换为zip格式的文件信息
        header, err := zip.FileInfoHeader(info)

        if err != nil{
            return err
        }

        if !info.IsDir() {
            // 确定采用的压缩算法（这个是内建注册的deflate）
            header.Method = zip.Deflate
        }

        //
        header.SetModTime(time.Unix(info.ModTime().Unix(), 0))

        //文件或者目录名
        header.Name = path

        //创建在zip内的文件或者目录
        writer, err := archive.CreateHeader(header)

        if err != nil{
            return err
        }

        //如果是目录，只需创建无需其他操作
        if info.IsDir() {
            return nil
        }

        //打开需要压缩的文件
        file, err := os.Open(path)

        if err != nil{
            return err
        }

        defer file.Close()

        //将待压缩文件拷贝给zip内文件
        _, err = io.Copy(writer, file)

        return err

    })
}

package main

import (
    "time"
    "fmt"
    "strings"
    "os"
    "archive/zip"
    "io/ioutil"
    "path/filepath"
    "io"
)

func main() {

    //oldFileName可以是文件或者目录
    oldFileName := "root.log"

    compressZip(oldFileName)
}

func compressZip(oldFileName string) string{

    fd, err := ioutil.ReadFile(oldFileName)

    if err != nil {
        fmt.Println("ReadFile ", oldFileName, "is error ", err)
        return ""
    }

    currentTime := time.Now()

    mSecond := fmt.Sprintf("%03d", currentTime.Nanosecond() / 1e6)

    zipFileName := strings.Split(oldFileName, ".")[0] + "_" + currentTime.Format("20060102150405") + mSecond + ".zip"

    fw, err := os.OpenFile(zipFileName, os.O_RDWR | os.O_CREATE | os.O_TRUNC, 400)

    if err != nil {
        fmt.Println("OpenFile ", zipFileName, "is error ", err)
        return ""
    }

    defer fw.Close()

    w := zip.NewWriter(fw)

    defer w.Close()

    f, err := w.Create(filepath.Base(oldFileName))

    if err != nil {
        fmt.Println("Create ", oldFileName, "is error ", err)
        return ""
    }

    _, err = f.Write(fd)

    if err != nil {
        fmt.Println("Write newFileName is error ", err)
        return ""
    }

    return zipFileName
}