在Go中列出目录

你可以尝试使用io/ioutil包中的ReadDir函数。根据文档:

ReadDir读取以dirname命名的目录，并返回一个已排序的目录条目列表。

结果片包含os.FileInfo类型，它们提供列出的在这里方法。下面是一个基本的例子，列出了当前目录中所有东西的名称(包含文件夹，但没有特别标记-你可以使用IsDir()方法检查一个项目是否为文件夹):

package main


import (
"fmt"
"io/ioutil"
"log"
)


func main() {
files, err := ioutil.ReadDir("./")
if err != nil {
log.Fatal(err)
}
 

for _, f := range files {
fmt.Println(f.Name())
}
}

ioutil.ReadDir是一个很好的发现，但是如果你点击并查看源代码，你会看到它调用了操作系统的Readdir。文件方法。如果您对目录顺序没有问题，并且不需要对列表排序，那么这个Readdir方法就是您所需要的全部。

更简单的是，使用path/filepath:

package main


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


func main() {
files, err := filepath.Glob("*")
if err != nil {
log.Fatal(err)
}
fmt.Println(files) // contains a list of all files in the current directory
}

我们可以使用各种golang标准库函数获得文件系统上某个文件夹中的文件列表。

1. filepath。走
2. ioutil。ReadDir
3. os.File.Readdir

package main


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


func main() {
var (
root  string
files []string
err   error
)


root := "/home/manigandan/golang/samples"
// filepath.Walk
files, err = FilePathWalkDir(root)
if err != nil {
panic(err)
}
// ioutil.ReadDir
files, err = IOReadDir(root)
if err != nil {
panic(err)
}
//os.File.Readdir
files, err = OSReadDir(root)
if err != nil {
panic(err)
}


for _, file := range files {
fmt.Println(file)
}
}

1. 使用filepath。走

path/filepath包提供了一种扫描所有文件的方便方法 在一个目录中，它会自动扫描每个子目录中的 目录。< / p >

func FilePathWalkDir(root string) ([]string, error) {
var files []string
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
files = append(files, path)
}
return nil
})
return files, err
}

2. 使用ioutil。ReadDir

ioutil.ReadDir读取dirname命名的目录并返回一个 目录项列表，按文件名排序

func IOReadDir(root string) ([]string, error) {
var files []string
fileInfo, err := ioutil.ReadDir(root)
if err != nil {
return files, err
}


for _, file := range fileInfo {
files = append(files, file.Name())
}
return files, nil
}

3. 使用os.File.Readdir

Readdir读取与文件和相关的目录的内容 返回最多n个FileInfo值的切片，就像返回 Lstat，按目录顺序。对同一文件的后续调用将会

. fileinfo .

. fileinfo .

func OSReadDir(root string) ([]string, error) {
var files []string
f, err := os.Open(root)
if err != nil {
return files, err
}
fileInfo, err := f.Readdir(-1)
f.Close()
if err != nil {
return files, err
}


for _, file := range fileInfo {
files = append(files, file.Name())
}
return files, nil
}

基准测试结果。

获取有关博客的更多详细信息

从你的描述中，你想要的可能是操作系统。Readdirnames。

func (f *File) Readdirnames(n int) (names []string, err error)

Readdirnames读取与file相关的目录的内容，并按目录顺序返回该目录中最多n个文件名的切片。对同一文件的后续调用将产生更多的名称。

.．.

如果n <= 0, Readdirnames在单个片中返回目录中的所有名称。

代码片段:

file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
names, err := file.Readdirnames(0)
if err != nil {
return err
}
fmt.Println(names)

贷给SquattingSlavInTracksuit的评论;如果可以的话，我会建议将他们的评论提升为一个答案。

从Go 1.16开始，你可以使用操作系统。ReadDir函数。

func ReadDir(name string) ([]DirEntry, error)

它读取给定的目录并返回一个DirEntry片，其中包含按文件名排序的目录条目。

它是一个乐观函数，因此，当读取目录条目时发生错误时，它会尝试返回一个切片，其中包含错误发生前的文件名。

package main


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


func main() {
files, err := os.ReadDir(".")
if err != nil {
log.Fatal(err)
}


for _, file := range files {
fmt.Println(file.Name())
}
}

感兴趣的:走1.17 (Q3 2021)包括fs.FileInfoToDirEntry():

func FileInfoToDirEntry(info FileInfo) DirEntry

FileInfoToDirEntry返回一个DirEntry，返回来自info的信息。
如果info为nil， FileInfoToDirEntry返回nil

背景

Go 1.16 (Q1 2021)将根据FS接口提出ReadDir函数，包含CL 243908和CL 243914:

// An FS provides access to a hierarchical file system.
//
// The FS interface is the minimum implementation required of the file system.
// A file system may implement additional interfaces,
// such as fsutil.ReadFileFS, to provide additional or optimized functionality.
// See io/fsutil for details.
type FS interface {
// Open opens the named file.
//
// When Open returns an error, it should be of type *PathError
// with the Op field set to "open", the Path field set to name,
// and the Err field describing the problem.
//
// Open should reject attempts to open names that do not satisfy
// ValidPath(name), returning a *PathError with Err set to
// ErrInvalid or ErrNotExist.
Open(name string) (File, error)
}

// ReadDir reads the contents of the directory associated with the file f
// and returns a slice of DirEntry values in directory order.
// Subsequent calls on the same file will yield later DirEntry records in the directory.
//
// If n > 0, ReadDir returns at most n DirEntry records.
// In this case, if ReadDir returns an empty slice, it will return an error explaining why.
// At the end of a directory, the error is io.EOF.
//
// If n <= 0, ReadDir returns all the DirEntry records remaining in the directory.
// When it succeeds, it returns a nil error (not io.EOF).
func (f *File) ReadDir(n int) ([]DirEntry, error)


// A DirEntry is an entry read from a directory (using the ReadDir method).
type DirEntry interface {
// Name returns the name of the file (or subdirectory) described by the entry.
// This name is only the final element of the path, not the entire path.
// For example, Name would return "hello.go" not "/home/gopher/hello.go".
Name() string
    

// IsDir reports whether the entry describes a subdirectory.
IsDir() bool
    

// Type returns the type bits for the entry.
// The type bits are a subset of the usual FileMode bits, those returned by the FileMode.Type method.
Type() os.FileMode
    

// Info returns the FileInfo for the file or subdirectory described by the entry.
// The returned FileInfo may be from the time of the original directory read
// or from the time of the call to Info. If the file has been removed or renamed
// since the directory read, Info may return an error satisfying errors.Is(err, ErrNotExist).
// If the entry denotes a symbolic link, Info reports the information about the link itself,
// not the link's target.
Info() (FileInfo, error)
}

src/os/os_test.go#testReadDir()说明了它的用法:

    file, err := Open(dir)
if err != nil {
t.Fatalf("open %q failed: %v", dir, err)
}
defer file.Close()
s, err2 := file.ReadDir(-1)
if err2 != nil {
t.Fatalf("ReadDir %q failed: %v", dir, err2)
}

本·霍伊特指向在评论中到Go 1.16 os.ReadDir:

os.ReadDir(path string) ([]os.DirEntry, error)，你可以直接调用它而不需要Open舞蹈。
所以你可以把它缩短为os.ReadDir，因为这是大多数人会调用的具体函数

参见提交3 d913a9 (december 2020):

os:添加ReadFile、WriteFile CreateTemp (TempFile) MkdirTemp io/ioutil (TempDir)

io/ioutil是一个定义不佳的helper集合。

建议# 40025将通用I/O帮助程序移出到io。 建议# 42026的CL将特定于操作系统的helper移动到os， 使整个io/ioutil包弃用

os.ReadDir返回[]DirEntry，与ioutil.ReadDir的[]FileInfo相反。
(提供一个返回[]DirEntry的帮助器是此更改的主要动机之一。

一个使用Readdirnames递归打印目录中所有文件的完整示例

package main


import (
"fmt"
"os"
)


func main() {
path := "/path/to/your/directory"
err := readDir(path)
if err != nil {
panic(err)
}
}


func readDir(path string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
names, _ := file.Readdirnames(0)
for _, name := range names {
filePath := fmt.Sprintf("%v/%v", path, name)
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
fileInfo, err := file.Stat()
if err != nil {
return err
}
fmt.Println(filePath)
if fileInfo.IsDir() {
readDir(filePath)
}
}
return nil
}