源码学习 go 语言中的文件操作（上）

该篇文章主要分析文件的打开和读取操作。

os 包的目录结构

os 包主要是为 go 语言的使用者提供平台无关的一致性接口。

os 中存在着大量以下的文件结构：

os/
    file.go
    file_plan9.go
    file_posix.go
    file_unix.go
    file_windows.go

它们即是为屏蔽不同平台的差异而存在的。

File 结构体

本文中，我们将以 unix 环境为例，来看一下文件操作的相关实现。

首先，我们来看一下 File 结构体。

os/file_unix.go

type File struct {
    *file
}

type file struct {
    fd      int
    name    string
    dirinfo *dirInfo // nil unless directory being read
}

File 结构体只是一个空壳，它里面包含了一个真正代表文件信息的 file 结构体。file 才是文件结构体的真身。

奇怪，此处为何要多此一举呢？

官方解释说这是为了避免使用者将 File 的数据覆盖，导致垃圾回收时关闭错误的文件描述符。原来，虽然 fd 是私有的成员，但是还是有可能通过 unsafe 等方式被修改。

这个结构体的内容很简单，其中 fd 是文件描述符，name 是文件的名字，dirinfo 只有在操作目录时才会用来，我们暂不关心。

创建 File

我们再来通过创建 File 的函数，更加深入地理解一下这几个字段。

os/file_unix.go

func NewFile(fd uintptr, name string) *File {
    fdi := int(fd)
    if fdi < 0 {
        return nil
    }
    f := &File{&file{fd: fdi, name: name}}
    runtime.SetFinalizer(f.file, (*file).close)
    return f
}

NewFile() 函数实例化一个 File 结构体，它接受两个参数：文件描述符和文件名。

这个函数很简单，它使用传入的参数创建一个 File 对象，并设置在垃圾回收时关掉文件该文件。当然，这是一个较低层的函数，它在 OpenFile() 是这样被使用的。

os/file_unix.go

func OpenFile(name string, flag int, perm FileMode) (*File, error) {
    // ...

    var r int
    var e error
    r, e = syscall.Open(name, flag|syscall.O_CLOEXEC, syscallMode(perm))

    // ...

    return NewFile(uintptr(r), name), nil
}

我们还是使用了之前的 trick，将我们不关心的代码省略了。此处我们看到，NewFile() 实际的作用只是创建一个结构体，打开文件之类的操作需要在创建结构体前完成。

打开文件函数

实际上我们刚才省略部分内容的 OpenFile() 函数，就是我们要关心打开文件里最重要的一个函数了。

虽然我们省略了部分内容，但是请不要担心，这些内容对我们的理解不会有太大的帮助。

我们看到，go 语言里操作函数是非常原始的，它只是对原生的系统调用稍加封装，并替换了错误处理的方式而已。

文章的最开始有一个文件名的模式，到此为止我们看的都是 os/file_unix.go 下的部分代码。实际上，平台无关性是通过 os/file.go 来实现的。

os/file.go 里提供了两个与打开文件有关的函数。

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)
}

是的，每个函数的函数体只有一行，它们是对 OpenFile() 函数的简单封装，或者说，只是一个简单的 wrapper，为我们提供更方便使用的快捷函数而已。

读取文件

os/file.go 中为我们提供了两个读取文件的函数。我们先来看第一个，从默认偏移处读取文件内容。

func (f *File) Read(b []byte) (n int, err error) {
    if f == nil {
        return 0, ErrInvalid
    }
    n, e := f.read(b)
    if n == 0 && len(b) > 0 && e == nil {       // 文件正常读完
        return 0, io.EOF
    }
    if e != nil {                   // 读取出错
        err = &PathError{"read", f.name, e}
    }
    return n, err
}

除了里面给出的两条注释，已经没有什么可写了。其中的 f.read() 几乎等价于直接执行系统的 read() 调用。几乎，意思是它还为我们屏蔽了不同平台间的差异。

这里有一点很值得我们学习，那就是对错误的处理。系统抛过来的错误是错误描述，而此函数，或者说此模块为错误信息加上了文件和具体操作的信息，这就让追踪错误变得更方便。有兴趣可以读一下 PathError，代码不多。

你应该还记得 read() 调用是如何工作的，操作系统维护一个文件偏移，读取一段内容后，偏移将自动调整。下次又会从新的偏移开始读取。

我们再来看第二个函数。

func (f *File) ReadAt(b []byte, off int64) (n int, err error) {
    if f == nil {
        return 0, ErrInvalid
    }
    for len(b) > 0 {
        m, e := f.pread(b, off)
        if m == 0 && e == nil {
            return n, io.EOF
        }
        if e != nil {
            err = &PathError{"read", f.name, e}
            break
        }
        n += m
        b = b[m:]
        off += int64(m)
    }
    return
}

奇怪，一个简单的读操作怎么还有 for 循环？

答案在 pread() 的实现里，我们来看一下。

os/file_unix.go

func (f *File) pread(b []byte, off int64) (n int, err error) {
    if needsMaxRW && len(b) > maxRW {
        b = b[:maxRW]
    }
    return fixCount(syscall.Pread(f.fd, b, off))
}

由于平台的特殊性，Darwin 和 FreeBSD 不能一次读写超过 2G 的文件内容，ReadAt() 在试图尽可能多地获取内容。

一个简单的读取文件 demo

package main

import (
    "log"
    "os"
)

func main() {
    file, err := os.Open("/tmp/hello.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    content := make([]byte, 100)
    n, err := file.Read(content)
    if err != nil {
        log.Fatal(err)
    }

    println(string(content[:n]))
}

归纳总结

这里我们把 file 暴露的与打开文件和读取文件有关的接口梳理如下。

打开文件：

func OpenFile(name string, flag int, perm FileMode) (*File, error)
func Open(name string) (*File, error)
func Create(name string) (*File, error)

读取文件：

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

下一篇，我们再来看一下写文件、关闭文件等剩下的文件操作。