In this article I explain how to get a list of files inside a folder on the filesystem, a task also called tree traversing, with Go.
There are two handy stdlib functions that you can use depending on your goal.
I list 3 ways: using filepath.Walk, ioutil.ReadDir or os.File.Readdir.
Using filepath.Walk
The path/filepath stdlib package provides the handy Walk function. It automatically scans subdirectories, though, so make sure this is what you actually want.
Usage is very simple:
package main
import (
"fmt"
"os"
"path/filepath"
)
func main() {
var files []string
root := "/some/folder/to/scan"
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
files = append(files, path)
return nil
})
if err != nil {
panic(err)
}
for _, file := range files {
fmt.Println(file)
}
}
filepath.Walk accepts a string pointing to the root folder, and a WalkFunc, a function type with signature
type WalkFunc func(path string, info os.FileInfo, err error) error
This function is called for each iteration of the folder scan.
The info variable of type os.FileInfo is important because we can get many information on the current file: the name, size, mode, modification time, if it’s a folder or a file, and the underlying data source.
For example we could avoid processing folders by adding
if info.IsDir() {
return nil
}
You can exclude (or include) files to the slice based on their extension, by using filepath.Ext and passing the file path:
if filepath.Ext(path) == ".dat" {
return nil
}
We could store the file name instead of the file path using
files = append(files, info.Name())
And we could also define the WalkFunc in a separate closure. We just need to pass a pointer to files in visit:
package main
import (
"fmt"
"log"
"os"
"path/filepath"
)
func visit(files *[]string) filepath.WalkFunc {
return func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Fatal(err)
}
*files = append(*files, path)
return nil
}
}
func main() {
var files []string
root := "/some/folder/to/scan"
err := filepath.Walk(root, visit(&files))
if err != nil {
panic(err)
}
for _, file := range files {
fmt.Println(file)
}
}
Using ioutil.ReadDir
filepath.Walk is handy but scans subfolders too, by default, which might not be what you want.
The Go stdlib also provides ioutil.ReadDir
func ReadDir(dirname string) ([]os.FileInfo, error)
ReadDir reads the directory named by dirname and returns a list of directory entries sorted by filename.
and here’s an example from the docs. ioutil.ReadDir takes a folder path as a string and returns a slice of os.FileInfo, which we described above.
package main
import (
"fmt"
"io/ioutil"
"log"
)
func main() {
files, err := ioutil.ReadDir(".")
if err != nil {
log.Fatal(err)
}
for _, file := range files {
fmt.Println(file.Name())
}
}
Using os.File.Readdir
Internally, ioutil.ReadDir is implemented as
// ReadDir reads the directory named by dirname and returns
// a list of directory entries sorted by filename.
func ReadDir(dirname string) ([]os.FileInfo, error) {
f, err := os.Open(dirname)
if err != nil {
return nil, err
}
list, err := f.Readdir(-1)
f.Close()
if err != nil {
return nil, err
}
sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
return list, nil
}
as you can see it scans dirname and sorts the files by name. If you don’t need sorting you can as well use
package main
import (
"fmt"
"log"
"os"
)
func main() {
dirname := "."
f, err := os.Open(dirname)
if err != nil {
log.Fatal(err)
}
files, err := f.Readdir(-1)
f.Close()
if err != nil {
log.Fatal(err)
}
for _, file := range files {
fmt.Println(file.Name())
}
}