上篇文章分析了文件操作中的打开和读取操作。这篇文章我们来分析一下文章的写入和关闭操作。
写入文件
在讨论写文件操作前，我们首先来回忆一下读文件的操作。
File.Read(b []byte) 函数会读取 len(b) 字节的文件内容到 b。理解起来挺简单，但是这里有一个问题需要注意，那就是 2G 界限的问题。
我们在上一篇文件中说，Darwin 和 FreeBSD 一次读写数据不能大于 2GB，go 使用了 1GB 来做为每次读取的界限。
那么，当读取大于 1GB 怎么办呢？
if needsMaxRW && len(b) > maxRW {
b = b[:maxRW]
}
Go 选择只读取 1GB 的数据，这样做问题不大。试想，我们的使用场景很多时候是这样的：
buf := make([]byte, 1024 * 1024 * 1024 * 3) // 3GB
for {
n, _ := f.Read(buf)
if n > 0 {
println(buf[:n])
}
}
为了演示方便，我省去了错误处理。当我们在 Darwin 上执行上面的命令时，虽然 b 是一个有 3GB 大小的数组，而且 f 的内容也足有 3GB，但第一次却只能读到 1GB 的数据。这不是问题，因为系统会为我们记录当前偏移，下次会从 1GB 的问题继续读取，这对我们的处理也没有问题。
假设我们有一段写文件操作的代码，与上面的读操作类似。
buf := make([]byte, 1024 * 1024 * 1024 * 3)
for {
n, _ := Get3GData(buf) // 获取将要写入的 3GB 数据
if n > 0 {
f.Write(buf) // (1)
}
}
代码几乎与读操作一一对应。但是这时问题来了，File.Write() 操作有 2GB（准确说是1GB）限制，也就是说这时我们有可能丢失了额外的 2GB 数据？
Go 当然不允许这样的事情发生，为了让写操作与读操作代码同样简洁，go 在实现上确保了 File.Write() 可以将 buf 的所有内容写入文件。我们来看一下 os 模块对写文件系统调用的封装。
os/file_unix.go
func (f *File) write(b []byte) (n int, err error) {
for {
bcap := b
if needsMaxRW && len(bcap) > maxRW { // (1)
bcap = bcap[:maxRW]
}
m, err := fixCount(syscall.Write(f.fd, bcap))
n += m
if 0 < m && m < len(bcap) || err == syscall.EINTR {
b = b[m:]
continue
}
if needsMaxRW && len(bcap) != len(b) && err == nil { // (2)
b = b[m:]
continue
}
return n, err
}
}
代码 (1) 处，如果当前系统存在 2GB 限制，将 bcap 限制到 1GB。代码 (2) 处，如果当前系统存在 2GB 限制，并且 len(b) 大于 1GB，让 b 偏移过已经成功读取的文件，并继续 for 循环。
File.Write() 的代码增加了对异常情况的包装处理，我们来看一下它的实现。
os/file.go
func (f *File) Write(b []byte) (n int, err error) {
if f == nil { // 无效文件
return 0, ErrInvalid
}
n, e := f.write(b)
if n < 0 { // 负值字节数处理
n = 0
}
if n != len(b) { // 错误字节数
err = io.ErrShortWrite
}
epipecheck(f, e) // pipe broken 处理，可以暂时忽略
if e != nil { // write() 错误处理
err = &PathError{"write", f.name, e}
}
return n, err
}
类似 File.ReadAt()，go 也实现了一个 File.WriteAt() 方法。
os/file.go
func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
if f == nil {
return 0, ErrInvalid
}
for len(b) > 0 {
m, e := f.pwrite(b, off)
if e != nil {
err = &PathError{"write", f.name, e}
break
}
n += m
b = b[m:]
off += int64(m)
}
return
}
其中，f.pwrite() 只是对系统调用 pwrite() 的简单封装。
如果你还记得我们的 File.ReadAt() 函数，你或许会发现它们惊人的相似。再如果你跟我一样无聊，或许也会把两个函数拿来对比一下。结果见下图。
关闭文件
func (f *File) Close() error {
if f == nil {
return ErrInvalid
}
return f.file.close()
}
func (file *file) close() error {
if file == nil || file.fd < 0 {
return syscall.EINVAL
}
var err error
if e := syscall.Close(file.fd); e != nil {
err = &PathError{"close", file.name, e}
}
file.fd = -1 // so it can't be closed again
// no need for a finalizer anymore
runtime.SetFinalizer(file, nil)
return err
}
关闭函数主要是对系统调用 close() 的简单封装。
在关闭文件后，系统调用了 runtime.SetFinalizer() 将 finalizer 清除。在上一篇中，我们看到在实例化 File 的 NewFile() 函数中，系统调用 runtime.SetFinalizer() 将 close() 函数设置为 File 的 finalizer。此时文件关闭，此 finalizer 已不再需要。
pread()、pwrite() 的特殊性
这是两个系统调用，之于 read() 和 write() 特殊之处在于，它们不会修改文件偏移。不过这个细节已经被 File.ReadAt(b []byte) 和 File.WriteAt(b []byte) 封装了，这两个函数会填充或写入所有的 b。
归纳总结
现在是时候列举一下我们这两天学过的接口了。
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)
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) Close() error
接下来？
这两篇文件讲到了文件读写操作，这是我们经常用到的功能。当然，还不全，因为还有设置读写偏移等其它的函数。
这些函数只是对系统调用的简单封装，如果需要，读者可以自行阅读。
如果你发现 os.Open() 和 os.Create() 不能满足你的需求，比如你想要的类似文件的 O_APPEND 选项，大胆的使用 OpenFile() 吧。