目錄
Go官方庫的文件操作分散在多個包中，比如os、ioutil、io包，強烈推薦你閱讀一下。
原文: Working with Files in Go, 作者: NanoDano
基本操作
創建空文件
package main
import (
"log"
"os"
)
func main() {
// 打開一個空的文件描述符
newFile, err := os.Create("test.txt")
if err != nil {
log.Fatal(err)
}
log.Println(newFile)
_ = newFile.Close()
}
Truncate文件
package main
import (
"log"
"os"
)
func main() {
// 裁剪一個文件到100個字節；
// 如果文件本來就少於100個字節，則文件中原始內容得以保留，剩余的字節以null字節填充；
// 如果文件本來超過100個字節，則超過的字節會被拋棄；
// 這樣我們總是得到精確的100個字節的文件；
// 傳入0則會清空文件。
err := os.Truncate("test.txt", 100)
if err != nil {
log.Fatal(err)
}
}
獲取文件信息
package main
import (
"fmt"
"log"
"os"
)
func main() {
// 如果文件不存在，則返回錯誤
fileInfo, err := os.Stat("test.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("File name:", fileInfo.Name())
fmt.Println("Size in bytes:", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Last modified:", fileInfo.ModTime())
fmt.Println("Is Directory: ", fileInfo.IsDir())
fmt.Printf("System interface type: %T\n", fileInfo.Sys())
fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
}
重命名、刪除、復制文件
package main
import (
"io"
"log"
"os"
)
func main() {
// rename
originalPath := "test.txt"
newPath := "test2.txt"
err := os.Rename(originalPath, newPath)
if err != nil {
log.Fatal(err)
}
// remove
err = os.Remove("test2.txt")
if err != nil {
log.Fatal(err)
}
// Copy
Copy()
}
func Copy() {
// TODO: copy
originalFile, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer originalFile.Close()
// 創建新的文件作為目標文件
newFile, err := os.Create("test_copy.txt")
if err != nil {
log.Fatal(err)
}
defer newFile.Close()
// 從源中復制字節到目標文件
bytesWritten, err := io.Copy(newFile, originalFile)
if err != nil {
log.Fatal(err)
}
log.Printf("Copied %d bytes.", bytesWritten)
// 將文件內容flush到硬盤中
err = newFile.Sync()
if err != nil {
log.Fatal(err)
}
}
func Copy2() {
srcFile, err := os.Open(srcFileName)
if err != nil {
fmt.Printf("open file err = %v\n", err)
return
}
defer srcFile.Close()
//通過srcFile，獲取到Reader
reader := bufio.NewReader(srcFile)
//打開dstFileName
dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
if err != nil {
fmt.Printf("open file err = %v\n", err)
return
}
writer := bufio.NewWriter(dstFile)
defer func() {
writer.Flush() //把緩沖區的內容寫入到文件
dstFile.Close()
}()
io.Copy(writer, reader)
}
打開和關閉文件
下面的屬性可以單獨使用，也可以組合使用。
組合使用時可以使用 OR 操作設置 OpenFile的第二個參數，例如：
os.O_CREATE|os.O_APPEND
或者 os.O_CREATE|os.O_TRUNC|os.O_WRONLY
os.O_RDONLY // 只讀
os.O_WRONLY // 只寫
os.O_RDWR // 讀寫
os.O_APPEND // 往文件中添建（Append）
os.O_CREATE // 如果文件不存在則先創建
os.O_TRUNC // 文件打開時裁剪文件
os.O_EXCL // 和O_CREATE一起使用，文件不能存在
os.O_SYNC // 以同步I/O的方式打開
package main
import (
"log"
"os"
)
func main() {
// 簡單地以只讀的方式打開。下面的例子會介紹讀寫的例子。
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
file.Close()
// OpenFile提供更多的選項。
file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
file.Close()
}
檢查文件是否存在
package main
import (
"log"
"os"
)
var (
fileInfo *os.FileInfo
err error
)
func main() {
// 文件不存在則返回error
fileInfo, err := os.Stat("test.txt")
if err != nil {
if os.IsNotExist(err) {
log.Fatal("File does not exist.")
}
}
log.Println("File does exist. File information:")
log.Println(fileInfo)
}
改變權限、擁有者、時間戳
package main
import (
"log"
"os"
"time"
)
func main() {
// 使用Linux風格改變文件權限
err := os.Chmod("test.txt", 0777)
if err != nil {
log.Println(err)
}
// 改變文件所有者
err = os.Chown("test.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Println(err)
}
// 改變時間戳
twoDaysFromNow := time.Now().Add(48 * time.Hour)
lastAccessTime := twoDaysFromNow
lastModifyTime := twoDaysFromNow
err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
if err != nil {
log.Println(err)
}
}
創建軟連接和硬鏈接
什么是硬鏈接？？
若一個 inode 號對應多個文件名，則稱這些文件為硬鏈接。換言之，硬鏈接就是同一個文件使用了多個別名
什么是軟鏈接？？
它不直接指向硬盤中的相同的地方，而是通過名字引用其它文件。刪除軟鏈接並不影響被指向的文件，但若被指向的原文件被刪除，則相關軟連接被稱為死鏈接
package main
import (
"os"
"log"
"fmt"
)
func main() {
err := os.Link("original.txt", "original_also.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("creating sym")
// Create a symlink
err = os.Symlink("original.txt", "original_sym.txt")
if err != nil {
log.Fatal(err)
}
// Lstat返回一個文件的信息，但是當文件是一個軟鏈接時，它返回軟鏈接的信息，而不是引用的文件的信息。
// Symlink在Windows中不工作。
fileInfo, err := os.Lstat("original_sym.txt")
if err != nil {
log.Fatal(err)
}
fmt.Printf("Link info: %+v", fileInfo)
//改變軟鏈接的擁有者不會影響原始文件。
err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Fatal(err)
}
}
判斷文件權限
package main
import (
"log"
"os"
)
func main() {
// 文件不存在則返回error
fileInfo, err := os.Stat("test.txt")
if err != nil {
if os.IsNotExist(err) {
log.Fatal("File does not exist.")
}
}
// TODO: how to
switch fileInfo.Mode().String() {
}
}
讀寫文件
寫文件
package main
import (
"log"
"os"
)
func main() {
// 可寫方式打開文件
file, err := os.OpenFile(
"test.txt",
os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
0666,
)
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 寫字節到文件中
byteSlice := []byte("Bytes!\n")
bytesWritten, err := file.Write(byteSlice)
// 寫文件字符串到文件
// bytesWritten, err := file.WriteString("string")
if err != nil {
log.Fatal(err)
}
log.Printf("Wrote %d bytes.", bytesWritten)
}
快速寫文件
ioutil包有一個非常有用的方法WriteFile()可以處理創建／打開文件、寫字節slice和關閉文件一系列的操作。如果你需要簡潔快速地寫字節slice到文件中，你可以使用它。
package main
import (
"io/ioutil"
"log"
)
func main() {
err := ioutil.WriteFile("test.txt", []byte("Hi\n"), 0666)
if err != nil {
log.Fatal(err)
}
}
使用緩存寫
bufio包提供了帶緩存功能的writer，所以你可以在寫字節到硬盤前使用內存緩存。當你處理很多的數據很有用，因為它可以節省操作硬盤I/O的時間。在其它一些情況下它也很有用，比如你每次寫一個字節，把它們攢在內存緩存中，然后一次寫入到硬盤中，減少硬盤的磨損以及提升性能。
package main
import (
"bufio"
"log"
"os"
)
func main() {
// 打開文件，只寫
file, err := os.OpenFile("test.txt", os.O_WRONLY,0666)
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 為這個文件創建buffered writer
bufferedWriter := bufio.NewWriter(file)
// 寫字節到buffer
bytesWritten, err := bufferedWriter.Write(
[]byte{65, 66, 67},
)
if err != nil {
log.Fatal(err)
}
log.Printf("Bytes written: %d\n", bytesWritten)
// 寫字符串到buffer
// 也可以使用 WriteRune() 和 WriteByte()
bytesWritten, err = bufferedWriter.WriteString(
"Buffered string\n",
)
// writebyte
// err = bufferedWriter.WriteByte(
// 'z',
// )
// writerune
// _, err = bufferedWriter.WriteRune(
// '中',
// )
if err != nil {
log.Fatal(err)
}
log.Printf("Bytes written: %d\n", bytesWritten)
// 檢查緩存中的字節數
unflushedBufferSize := bufferedWriter.Buffered()
log.Printf("Bytes buffered: %d\n", unflushedBufferSize)
// 還有多少字節可用（未使用的緩存大小）
bytesAvailable := bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
// 寫內存buffer到硬盤
bufferedWriter.Flush()
// 丟棄還沒有flush的緩存的內容，清除錯誤並把它的輸出傳給參數中的writer
// 當你想將緩存傳給另外一個writer時有用
bufferedWriter.Reset(bufferedWriter)
bytesAvailable = bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
// 重新設置緩存的大小。
// 第一個參數是緩存應該輸出到哪里，這個例子中我們使用相同的writer。
// 如果我們設置的新的大小小於第一個參數writer的緩存大小， 比如10，我們不會得到一個10字節大小的緩存，
// 而是writer的原始大小的緩存，默認是4096。
// 它的功能主要還是為了擴容。
bufferedWriter = bufio.NewWriterSize(
bufferedWriter,
8000,
)
// resize后檢查緩存的大小
bytesAvailable = bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
}
讀取最多N個字節
os.File提供了文件操作的基本功能， 而io、ioutil、bufio提供了額外的輔助函數。
package main
import (
"log"
"os"
)
func main() {
// 打開文件，只讀
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 從文件中讀取len(b)字節的文件。
// 返回0字節意味着讀取到文件尾了
// 讀取到文件會返回io.EOF的error
byteSlice := make([]byte, 16)
bytesRead, err := file.Read(byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", bytesRead)
log.Printf("Data read: %s\n", byteSlice)
}
讀取至少N字節
package main
import (
"io"
"log"
"os"
)
func main() {
// 打開文件，只讀
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
byteSlice := make([]byte, 512)
minBytes := 8
// io.ReadAtLeast()在不能得到最小的字節的時候會返回錯誤(unexpected EOF)，但會把已讀的文件保留
numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", numBytesRead)
log.Printf("Data read: %s\n", byteSlice)
}
讀取全部字節
package main
import (
"fmt"
"io/ioutil"
"log"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
// os.File.Read(), io.ReadFull() 和
// io.ReadAtLeast() 在讀取之前都需要一個固定大小的byte slice。
// 但ioutil.ReadAll()會讀取reader(這個例子中是file)的每一個字節，然后把字節slice返回。
data, err := ioutil.ReadAll(file)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Data as hex: %x\n", data)
fmt.Printf("Data as string: %s\n", data)
fmt.Println("Number of bytes read:", len(data))
}
快讀到內存
package main
import (
"io/ioutil"
"log"
)
func main() {
// 讀取文件到byte slice中
data, err := ioutil.ReadFile("test.txt")
if err != nil {
log.Fatal(err)
}
log.Printf("Data read: %s\n", data)
}
使用緩存讀
有緩存寫也有緩存讀。
緩存reader會把一些內容緩存在內存中。它會提供比os.File和io.Reader更多的函數,缺省的緩存大小是4096，最小緩存是16。
TODO: 使用場景
package main
import (
"os"
"log"
"bufio"
"fmt"
)
func main() {
// 打開文件，創建buffered reader
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
bufferedReader := bufio.NewReader(file)
// 得到字節，當前指針不變
byteSlice := make([]byte, 5)
byteSlice, err = bufferedReader.Peek(5)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Peeked at 5 bytes: %s\n", byteSlice)
// 讀取，指針同時移動
numBytesRead, err := bufferedReader.Read(byteSlice)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)
// 讀取一個字節, 如果讀取不成功會返回Error
myByte, err := bufferedReader.ReadByte()
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read 1 byte: %c\n", myByte)
// 讀取到分隔符，包含分隔符，返回byte slice
dataBytes, err := bufferedReader.ReadBytes('\n')
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read bytes: %s\n", dataBytes)
// 讀取到分隔符，包含分隔符，返回字符串
dataString, err := bufferedReader.ReadString('\n')
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read string: %s\n", dataString)
//這個例子讀取了很多行，所以test.txt應該包含多行文本才不至於出錯
}
按行讀取
package main
import (
"bufio"
"log"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
scanner := bufio.NewScanner(file)
// 缺省的分隔函數是bufio.ScanLines,我們這里使用ScanWords
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
log.Print(scanner.Text())
}
}