go語言檔案操作
阿新 • • 發佈:2020-12-19
go語言檔案操作
目錄基本操作
建立空檔案
package main import ( "log" "os" ) var ( newFile *os.File err error ) func main() { newFile, err = os.Create("test.txt") if err != nil { log.Fatal(err) } log.Println(newFile) newFile.Close() }
擷取檔案
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" ) var ( fileInfo os.FileInfo err error ) 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 (
"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"
)
func main() {
// 簡單地以只讀的方式開啟。下面的例子會介紹讀寫的例子。
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
file.Close()
// OpenFile提供更多的選項。
// 最後一個引數是許可權模式permission mode
// 第二個是開啟時的屬性
file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
file.Close()
// 下面的屬性可以單獨使用,也可以組合使用。
// 組合使用時可以使用 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() {
err := os.Remove("test.txt")
if err != nil {
log.Fatal(err)
}
}
重新命名和移動
package main
import (
"log"
"os"
)
func main() {
originalPath := "test.txt"
newPath := "test2.txt"
err := os.Rename(originalPath, newPath)
if err != nil {
log.Fatal(err)
}
}
檢查讀寫許可權
package main
import (
"log"
"os"
)
func main() {
// 這個例子測試寫許可權,如果沒有寫許可權則返回error。
// 注意檔案不存在也會返回error,需要檢查error的資訊來獲取到底是哪個錯誤導致。
file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Write permission denied.")
}
}
file.Close()
// 測試讀許可權
file, err = os.OpenFile("test.txt", os.O_RDONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Read permission denied.")
}
}
file.Close()
}
改變許可權等資訊
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)
}
}
讀寫檔案
複製檔案
package main
import (
"os"
"log"
"io"
)
func main() {
// 開啟原始檔案
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)
}
}
跳轉到檔案指定位置(Seek)
package main
import (
"os"
"fmt"
"log"
)
func main() {
file, _ := os.Open("test.txt")
defer file.Close()
// 偏離位置,可以是正數也可以是負數
var offset int64 = 5
// 用來計算offset的初始位置
// 0 = 檔案開始位置
// 1 = 當前位置
// 2 = 檔案結尾處
var whence int = 0
newPosition, err := file.Seek(offset, whence)
if err != nil {
log.Fatal(err)
}
fmt.Println("Just moved to 5:", newPosition)
// 從當前位置回退兩個位元組
newPosition, err = file.Seek(-2, 1)
if err != nil {
log.Fatal(err)
}
fmt.Println("Just moved back two:", newPosition)
// 使用下面的技巧得到當前的位置
currentPosition, err := file.Seek(0, 1)
fmt.Println("Current position:", currentPosition)
// 轉到檔案開始處
newPosition, err = file.Seek(0, 0)
if err != nil {
log.Fatal(err)
}
fmt.Println("Position after seeking 0,0:", newPosition)
}
寫檔案
package main
import (
"os"
"log"
)
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)
if err != nil {
log.Fatal(err)
}
log.Printf("Wrote %d bytes.\n", 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 (
"log"
"os"
"bufio"
)
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",
)
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 (
"os"
"log"
)
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 (
"os"
"log"
"io"
)
func main() {
// Open file for reading
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
// file.Read()可以讀取一個小檔案到大的byte slice中,
// 但是io.ReadFull()在檔案的位元組數小於byte slice位元組數的時候會返回錯誤
byteSlice := make([]byte, 2)
numBytesRead, err := io.ReadFull(file, byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", numBytesRead)
log.Printf("Data read: %s\n", byteSlice)
}
讀取至少N個位元組
package main
import (
"os"
"log"
"io"
)
func main() {
// 開啟檔案,只讀
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
byteSlice := make([]byte, 512)
minBytes := 8
// io.ReadAtLeast()在不能得到最小的位元組的時候會返回錯誤,但會把已讀的檔案保留
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 (
"os"
"log"
"fmt"
"io/ioutil"
)
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 (
"log"
"io/ioutil"
)
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。
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應該包含多行文字才不至於出錯
}
壓縮打包
打包(zip) 檔案
// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"log"
"os"
)
func main() {
// 建立一個打包檔案
outFile, err := os.Create("test.zip")
if err != nil {
log.Fatal(err)
}
defer outFile.Close()
// 建立zip writer
zipWriter := zip.NewWriter(outFile)
// 往打包檔案中寫檔案。
// 這裡我們使用硬編碼的內容,你可以遍歷一個資料夾,把資料夾下的檔案以及它們的內容寫入到這個打包檔案中。
var filesToArchive = []struct {
Name, Body string
} {
{"test.txt", "String contents of file"},
{"test2.txt", "\x61\x62\x63\n"},
}
// 下面將要打包的內容寫入到打包檔案中,依次寫入。
for _, file := range filesToArchive {
fileWriter, err := zipWriter.Create(file.Name)
if err != nil {
log.Fatal(err)
}
_, err = fileWriter.Write([]byte(file.Body))
if err != nil {
log.Fatal(err)
}
}
// 清理
err = zipWriter.Close()
if err != nil {
log.Fatal(err)
}
}
抽取(unzip) 檔案
// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"log"
"io"
"os"
"path/filepath"
)
func main() {
zipReader, err := zip.OpenReader("test.zip")
if err != nil {
log.Fatal(err)
}
defer zipReader.Close()
// 遍歷打包檔案中的每一檔案/資料夾
for _, file := range zipReader.Reader.File {
// 打包檔案中的檔案就像普通的一個檔案物件一樣
zippedFile, err := file.Open()
if err != nil {
log.Fatal(err)
}
defer zippedFile.Close()
// 指定抽取的檔名。
// 你可以指定全路徑名或者一個字首,這樣可以把它們放在不同的資料夾中。
// 我們這個例子使用打包檔案中相同的檔名。
targetDir := "./"
extractedFilePath := filepath.Join(
targetDir,
file.Name,
)
// 抽取專案或者建立資料夾
if file.FileInfo().IsDir() {
// 建立資料夾並設定同樣的許可權
log.Println("Creating directory:", extractedFilePath)
os.MkdirAll(extractedFilePath, file.Mode())
} else {
//抽取正常的檔案
log.Println("Extracting file:", file.Name)
outputFile, err := os.OpenFile(
extractedFilePath,
os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
file.Mode(),
)
if err != nil {
log.Fatal(err)
}
defer outputFile.Close()
// 通過io.Copy簡潔地複製檔案內容
_, err = io.Copy(outputFile, zippedFile)
if err != nil {
log.Fatal(err)
}
}
}
}
壓縮檔案
// 這個例子中使用gzip壓縮格式,標準庫還支援zlib, bz2, flate, lzw
package main
import (
"os"
"compress/gzip"
"log"
)
func main() {
outputFile, err := os.Create("test.txt.gz")
if err != nil {
log.Fatal(err)
}
gzipWriter := gzip.NewWriter(outputFile)
defer gzipWriter.Close()
// 當我們寫如到gizp writer資料時,它會依次壓縮資料並寫入到底層的檔案中。
// 我們不必關心它是如何壓縮的,還是像普通的writer一樣操作即可。
_, err = gzipWriter.Write([]byte("Gophers rule!\n"))
if err != nil {
log.Fatal(err)
}
log.Println("Compressed data written to file.")
}
解壓縮檔案
// 這個例子中使用gzip壓縮格式,標準庫還支援zlib, bz2, flate, lzw
package main
import (
"compress/gzip"
"log"
"io"
"os"
)
func main() {
// 開啟一個gzip檔案。
// 檔案是一個reader,但是我們可以使用各種資料來源,比如web伺服器返回的gzipped內容,
// 它的內容不是一個檔案,而是一個記憶體流
gzipFile, err := os.Open("test.txt.gz")
if err != nil {
log.Fatal(err)
}
gzipReader, err := gzip.NewReader(gzipFile)
if err != nil {
log.Fatal(err)
}
defer gzipReader.Close()
// 解壓縮到一個writer,它是一個file writer
outfileWriter, err := os.Create("unzipped.txt")
if err != nil {
log.Fatal(err)
}
defer outfileWriter.Close()
// 複製內容
_, err = io.Copy(outfileWriter, gzipReader)
if err != nil {
log.Fatal(err)
}
}