Golang: Walk Directory

to go thru all files and directory, use

filepath.Walk(dir_path, process_func)

from package path/filepath

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

var myDir = "/Users/x/web/"

// go thru a dir and print all file name and extension

func main() {
    // the function that handles each file or dir
    var ff = func(pathX string, infoX os.FileInfo, errX error) error {

    // first thing to do, check error. and decide what to do about it
        if errX != nil {
        fmt.Printf("error 「%v」 at a path 「%q」\n", errX, pathX)
        return errX
    }

    fmt.Printf("pathX: %v\n", pathX)

    // find out if it's a dir or file, if file, print info
        if infoX.IsDir() {
        fmt.Printf("is dir.\n")
    } else {
        fmt.Printf("  dir: 「%v」\n", filepath.Dir(pathX))
        fmt.Printf("  file name 「%v」\n", infoX.Name())
        fmt.Printf("  extenion: 「%v」\n", filepath.Ext(pathX))
    }

    return nil
    }

    err := filepath.Walk(myDir, ff)

    if err != nil {
    fmt.Printf("error walking the path %q: %v\n", myDir, err)
    }
}

filepath.Walk(dir_path, ff) walks dir_path, for each file or dir, it calls ff

when there's a problem, a error is passed to ff. ff can do whatever with it.

ff must return one of:

• value of type error. (error is a interface)
• nil
• filepath.SkipDir

• If ff returns a error, then filepath.Walk returns a error. The walk is stopped
• If ff returns filepath.SkipDir, then filepath.Walk will do skip: if current path is dir, skip it, but current path is a file, then skip rest of files in the directory

Argument Passed to the Walker Function

filepath.Walk(myDir, ff) passes 3 arguments to ff.

ff is the walker function that you must write. It process each path.

The arguments passed to the walker are:

• arg1 string → this is the full path of current file or directory.
• arg2 os.FileInfo → this is a value that implements the os.FileInfo interface. It contain info about the file. e.g. arg2.IsDir() to check if it's dir or file. arg2.Size() to get file size.
• arg3 error. → if there's a error, it's passed to your walker function.

In your walker function, you must delare the types accordingly. e.g.

var walker = func(pathX string, infoX os.FileInfo, errX error) error {…}

FileInfo

A FileInfo describes a file and is returned by Stat and Lstat.

type FileInfo interface {
    Name() string       // base name of the file
    Size() int64        // length in bytes for regular files; system-dependent for others
    Mode() FileMode     // file mode bits
    ModTime() time.Time // modification time
    IsDir() bool        // abbreviation for Mode().IsDir()
    Sys() interface{}   // underlying data source (can return nil)
}

error

The error built-in interface type is the conventional interface for representing an error condition, with the nil value representing no error.

type error interface {
    Error() string
}

Alternative

there is a well known problem that filepath.Walk is slow, not implemented optimally.

see https://github.com/golang/go/issues/16399

here's alternative: https://github.com/karrick/godirwalk/blob/master/README.md