上篇文章分析了文件操作中的打開和讀取操作。這篇文章我們來分析一下文章的寫入和關閉操作。
寫入文件
在討論寫文件操作前，我們首先來回憶一下讀文件的操作。
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() 吧。
