[go]文件与目录操作

文件操作是常见的，go中主要涉及到os、io包以及filepath（路径处理推荐使用 path/filepath替代path包）。

文件操作

文件打开

文件打开函数为os包中的OpenFile(name string, flag int, perm FileMode) (*File, error)

• flag指定了文件的访问模式

  const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR int = syscall.O_RDWR // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT // 如果不存在将创建一个新文件
    O_EXCL int = syscall.O_EXCL // 和 O_CREATE 配合使用，文件必须不存在
    O_SYNC int = syscall.O_SYNC // 打开文件用于同步 I/O
    O_TRUNC int = syscall.O_TRUNC // 如果可能，打开时清空文件
  )
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• perm指定了权限位os.FileMode

  const (
    // 单字符是被 String 方法用于格式化的属性缩写。
    ModeDir FileMode = 1 << (32 - 1 - iota) // d: 目录
    ModeAppend // a: 只能写入，且只能写入到末尾
    ModeExclusive // l: 用于执行
    ModeTemporary // T: 临时文件（非备份文件）
    ModeSymlink // L: 符号链接（不是快捷方式文件）
    ModeDevice // D: 设备
    ModeNamedPipe // p: 命名管道（FIFO）
    ModeSocket // S: Unix 域 socket
    ModeSetuid // u: 表示文件具有其创建者用户 id 权限
    ModeSetgid // g: 表示文件具有其创建者组 id 的权限
    ModeCharDevice // c: 字符设备，需已设置 ModeDevice
    ModeSticky // t: 只有 root/ 创建者能删除 / 移动文件
  
    // 覆盖所有类型位（用于通过 & 获取类型位），对普通文件，所有这些位都不应被设置
    ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
    ModePerm FileMode = 0777 // 覆盖所有 Unix 权限位（用于通过 & 获取类型位）
  )
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

有两个简化函数，方便文件读取与创建：

func Open(name string) (*File, error) {
    return OpenFile(name, O_RDONLY, 0)
}

func Create(name string) (*File, error) {
    return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}
1
2
3
4
5
6
7

读文件

以读方式打开的文件，才可读取其内容：

file, err := os.Open("tmp.txt")
if err != nil {
    // 错误处理
    return
}
defer file.Close()
1
2
3
4
5
6

通过文件句柄读取文件内容：

// func (f *File) Read(b []byte) (n int, err error)
// func (f *File) ReadAt(b []byte, off int64) (n int, err error)

var all []byte
buf := make([]byte, 1024)
for{
    n, err := file.Read(buf)
    if err != nil && err != io.EOF{
        fmt.Println("Read fail:", err)
        return
    }
    
    if n == 0 { //读取到文件尾
        break
    }
    all = append(all, buf[:n]...)
}
fmt.Println("Content: ", string(all))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

直接读取

在os中提供了直接读取文件内容的方法：

// func ReadFile(name string) ([]byte, error)

data, err := os.ReadFile("tmp.txt")
if err == nil{
    fmt.Println(string(data))
}
1
2
3
4
5
6

NewReader读取

通过Reader可直接读取字符串、字节、数组等：

// func (b *Reader) Read(p []byte) (n int, err error)
// func (b *Reader) ReadByte() (byte, error)
// func (b *Reader) ReadRune() (r rune, size int, err error)

// 按分隔符读取（读取的内容包含分隔符）
// func (b *Reader) ReadBytes(delim byte) ([]byte, error)
// func (b *Reader) ReadString(delim byte) (string, error)

reader := bufio.NewReader(file)
for {
    line, err := reader.ReadString('\n')
    if err != nil{
        if err == io.EOF{
            fmt.Println("End of file")
            break
        }
        return err
    }

    fmt.Println(line)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

io库中提供了通过操作Reader进行读取的方法：

func ReadAll(r Reader) ([]byte, error)

// 没读取到任何内容时，返回EOF
// 读取到文件尾，但内容
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)

// 没读取到任何内容时，返回EOF
// 读取到文件尾，但内容
func ReadFull(r Reader, buf []byte) (n int, err error)
1
2
3
4
5
6
7
8
9

Scanner按行读取

Scanner把读取的数据流按Tokens（默认为‘换行符’）分割：

fHandle, err := os.Open(fileName)
if err != nil {
	log.Printf("[ERROR] open file %v fail: %v", fileName, err)
	return
}
defer fHandle.Close()

scan := bufio.NewScanner(fHandle)
// scan.Split(bufio.ScanLines)  // 设定分割方式，默认换行符

for scan.Scan() { // 失败、或到文件尾时返回false
	lines = append(lines, scan.Text())
}
err = scan.Err() // 返回出EOF外遇到的第一个错误
if err != nil {
	log.Printf("[ERROR] scan file fail: %v", err)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

写文件

写文件要创建文件，或以写权限打开文件：

// func (f *File) Write(b []byte) (n int, err error)
// func (f *File) WriteAt(b []byte, off int64) (n int, err error)
// func (f *File) WriteString(s string) (n int, err error)

file, err := os.Create("tmp.txt")
if err != nil {
    return err
}
defer file.Close()
1
2
3
4
5
6
7
8
9

直接写文件

通过os中WriteFile可直接写文件：

• 若文件不存在，则使用perm权限新建文件；
• 若文件存在，则以truncate的方式写入；

// func WriteFile(name string, data []byte, perm FileMode) error

err := os.WriteFile("testdata/hello", []byte(str), 0666)
if err != nil{
    // handle error
}
1
2
3
4
5
6

NewWriter写

Writer中可直接写字符串、字节、数组等：

// func (b *Writer) Write(p []byte) (nn int, err error)
// func (b *Writer) WriteByte(c byte) error
// func (b *Writer) WriteRune(r rune) (size int, err error)
// func (b *Writer) WriteString(s string) (int, error)

writer := bufio.NewWriter(file)
count, err := writer.WriteString(str)
1
2
3
4
5
6
7

io中提供了通过writer写的方法：

func WriteString(w Writer, s string) (n int, err error)
1

文件属性

通过os的Stat方法可获取文件属性信息：

// func Stat(name string) (FileInfo, error)

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() any           // underlying data source (can return nil)
}
1
2
3
4
5
6
7
8
9
10

通过os的IsNotExist，可判断文件是否存在：

// func IsExist(err error) bool // 在文件创建失败时判断
// func IsNotExist(err error) bool

   fInfo, err := os.Stat("tmp.txt")
   if err != nil {
       fmt.Println(err)

       //校验错误是否为【文件不存在错误】
       if os.IsNotExist(err){
           fmt.Println("文件不存在！")
       }
       return err
   }
1
2
3
4
5
6
7
8
9
10
11
12
13

其他操作函数

在os与io中还提供了很多常用文件操作函数

os包中提供了修改属性、时间，以及删除、重命名的方法：

func Chmod(name string, mode FileMode) error
func Chown(name string, uid, gid int) error
func Chtimes(name string, atime time.Time, mtime time.Time) error

// 读取软连接对应的实际文件路径
func Readlink(name string) (string, error)

func Remove(name string) error
func Rename(oldpath, newpath string) error
1
2
3
4
5
6
7
8
9

io包中提供了文件复制的方法

// func Copy(dst Writer, src Reader) (written int64, err error)
// func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

// 把字符串内容输出到屏幕上
reader := strings.NewReader("reader examples to show on screen!")
if _, err := io.Copy(os.Stdout, reader); err != nil{
    // handle error
}
1
2
3
4
5
6
7
8

也可通过os中的ReadFile与WriteFile配合实现文件复制。

计算MD5

通过copy也可方便地计算文件的MD5值：

func calcMD5() {
    fh, err := os.Open("tmp.txt")
    if err != nil {
        fmt.Println("ERROR:", err)
        return
    }
    defer fh.Close()

    md5h := md5.New()
    io.Copy(md5h, fh)

    value := hex.EncodeToString(md5h.Sum([]byte("")))
    fmt.Println(value)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

目录操作

目录创建与删除：

func Mkdir(name string, perm FileMode) error
// 递归创建多层目录
func MkdirAll(path string, perm FileMode) error

// 目录非空时出错
func Remove(name string) error
// 移除目录及其子目录
func RemoveAll(path string) error　

// 移动/重命名
func Rename(oldpath, newpath string) error
1
2
3
4
5
6
7
8
9
10
11

读取目录ReadDir

通过os.ReadDir可获取文件夹下的所有子文件（不递归遍历）：

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

type DirEntry interface {
    // 文件名(the base name), 不包括路径
    Name() string

    IsDir() bool
    
    Type() FileMode

    // 若获取时，文件已被删除（遍历后删除的），会返回ErrNotExist错误
    // 对软连接，是软连接本身的属性
    Info() (FileInfo, error)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

获取目录下的所有子文件与文件夹：

func listDir(root string) {
    dirs, err := os.ReadDir(root)
    if err != nil {
        fmt.Println("ERROR:", err)
        return
    }

    fmt.Println("Files under", root)
    for _, entry := range dirs {
        fmt.Printf("\t%v is dir %v\n", entry.Name(), entry.IsDir())
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

遍历目录树

通过filepath模块中的walk函数，可遍历目录树，通过参数fn可控制遍历结果：

• 返回error：退出遍历，并返回此错误作为walk的返回；
• 返回filepath.SkipDir：跳过此文件夹的遍历，继续遍历其他的；

func Walk(root string, fn WalkFunc) error
// type WalkFunc func(path string, info fs.FileInfo, err error) error
// !!path包括root（即root为绝对路径时，path为全路径）

func WalkDir(root string, fn fs.WalkDirFunc) error
// type WalkDirFunc func(path string, d DirEntry, err error) error
1
2
3
4
5
6

遍历目录树：

func walkDir(root string) {
    err := filepath.Walk(root, func(path string, info fs.FileInfo, err error) error {
        if err != nil {
            fmt.Printf("ERROR, walk path %q fail: %v\n", path, err)
            return err
        }

        if info.IsDir() && info.Name() == "result" {
            fmt.Printf("!!skip result path: %+v \n", info.Name())
            return filepath.SkipDir
        }

        fmt.Printf("\tvisited %q is dir %v\n", path, info.IsDir())
        return nil
    })

    if err != nil {
        fmt.Println(err)
        return
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

路径模糊匹配

通过filepath包中的Glob可直接返回满足条件的文件，而通过Match可对获取到的文件进行匹配处理：

func Glob(pattern string) (matches []string, err error)

// name是否与pattern匹配
func Match(pattern, name string) (matched bool, err error)
1
2
3
4

Pattern为匹配模式:

• *: 匹配0或多个非路径分隔符的字符
• ?: 匹配1个非路径分隔符的字符
• [ ... ]: 匹配指定字符，或范围（如[a-h]），或不包含的（如[^e]）

路径操作

path/filepath包包含了路径操作函数；路径分隔符统一为os.PathSeparator。

解析路径（文件名、扩展名）

// 所在路径：去掉最后一个路径分隔符后剩余部分（path不要以路径分隔符结尾，否则只是截去了分隔符）
func Dir(path string) string

// 文件名
func Base(path string) string

// 扩展名；无扩展名时，返回空字符串
func Ext(path string) string
1
2
3
4
5
6
7
8

尾部分隔符会影响Dir的分割，但不影响Base：

• .，返回：Dir: ., Base: .
• 空字符串``，返回：Dir: ., Base: .
• /，返回：Dir: /, Base: /
• /temp/Picture，返回：Dir: /temp, Base: Picture
• /temp/Picture/，返回：Dir: /temp/Picture, Base: Picture

相对路径和绝对路径

绝对路径，在linux下，以/开始；在Windows 下以某个盘符开始，比如 C:\Program Files

func IsAbs(path string) bool

// 返回绝对路径；若path不是绝对路径，会组合当前工作目录使之成为绝对路径
func Abs(path string) (string, error)

// 若成功，返回targpath相对basepath的相对路径
func Rel(basepath, targpath string) (string, error)
1
2
3
4
5
6
7

路径组合、拆分操作

func Split(path string) (dir, file string)

// 分割路径（环境变量中PATH）
// Windows下以分号分割的字符串；Linux以冒号分割的字符串
func SplitList(path string) []string

func Join(elem ...string) string

// 规整化路径：
func Clean(path string) string
1
2
3
4
5
6
7
8
9
10