使用 Golang 获取目录磁盘使用情况

我相信您误用了syscall.Statfs function:它返回file system statistics，而不是单个目录或文件的大小.因此，您看到的输出不是单个目录的大小，而是这些目录所在的文件系统的总体磁盘使用率.

如果您不想使用filepath.Walk(这实际上是通过递归遍历所有文件来计算目录大小的好方法)，您可以使用your own recursive function.

package main

import (
    "os"
    "log"
    "fmt"
)

const (
    B  = 1
    KB = 1024 * B
    MB = 1024 * KB
    GB = 1024 * MB
)

func DirSize(path string) (int64, error) {
    var size int64
    entries, err := os.ReadDir(path)
    if err != nil {
        return size, err
    }
    for _, entry := range entries {
        if entry.IsDir() {
            subDirSize, err := DirSize(path + "/" + entry.Name())
            if err != nil {
                log.Printf("failed to calculate size of directory %s: %v\n", entry.Name(), err)
                continue
            }
            size += subDirSize
        } else {
            fileInfo, err := entry.Info()
            if err != nil {
                log.Printf("failed to get info of file %s: %v\n", entry.Name(), err)
                continue
            }
            size += fileInfo.Size()
        }
    }
    return size, nil
}

func main() {
    dirs := []string{"./containers", "./testfolder", "./workspace"}

    for _, dir := range dirs {
        size, err := DirSize(dir)
        if err != nil {
            log.Printf("failed to calculate size of directory %s: %v\n", dir, err)
            continue
        }
        fmt.Printf("%s --> %.2f GB\n", dir, float64(size)/float64(GB))
    }
}

That would go through each directory and file under the given directory and sum up the sizes.
If the entry is a directory, it will recursively calculate the size of the directory.
Although... this code will not handle symbolic links or other special files.

The other option is for the DirSize function uses filepath.Walk to traverse all files under the specified directory, including subdirectories.
The filepath.Walk function takes two arguments: the root directory and a function that will be called for each file or directory in the tree rooted at the root.

Here, for each file it encounters, it adds the size of the file to the total size (ignoring directories).
Since filepath.Walk automatically handles recursive traversal for you, it is generally simpler and more straightforward than manually writing the recursive function.
(playground)

package main

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

const (
    B  = 1
    KB = 1024 * B
    MB = 1024 * KB
    GB = 1024 * MB
)

func DirSize(path string) (int64, error) {
    var size int64
    err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if !info.IsDir() {
            size += info.Size()
        }
        return err
    })
    return size, err
}

func main() {
    dirs := []string{"./containers", "./testfolder", "./workspace"}

    for _, dir := range dirs {
        size, err := DirSize(dir)
        if err != nil {
            log.Printf("failed to calculate size of directory %s: %v\n", dir, err)
            continue
        }
        fmt.Printf("%s --> %.2f GB\n", dir, float64(size)/float64(GB))
    }
}