Go文件操作大全

Go官方庫的文件操作分散在多個包中，比如 os 、 ioutil 包，我本來想寫一篇總結性的Go文件操作的文章，卻發現已經有人2015年已經寫了一篇這樣的文章，寫的非常好，所以我翻譯成了中文，強烈推薦你閱讀一下。

介紹

萬物皆文件

UNIX 的一個基礎設計就是"萬物皆文件"(everything is a file)。我們不必知道一個文件到底映射成什么，操作系統的設備驅動抽象成文件。操作系統為設備提供了文件格式的接口。

Go語言中的reader和writer接口也類似。我們只需簡單的讀寫字節，不必知道reader的數據來自哪里，也不必知道writer將數據發送到哪里。

你可以在 /dev 下查看可用的設備，有些可能需要較高的權限才能訪問。

基本操作

創建一個空文件

packagemain

import(
"log"
"os"
)

var(
 newFile *os.File
 err error
)

funcmain() {
 newFile, err = os.Create("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
 log.Println(newFile)
 newFile.Close()
}

Truncate一個饑餓文件

packagemain

import(
"log"
"os"
)

funcmain() {
// 裁剪一個文件到100個字節。
// 如果文件本來就少于100個字節，則文件中原始內容得以保留，剩余的字節以null字節填充。
// 如果文件本來超過100個字節，則超過的字節會被拋棄。
// 這樣我們總是得到精確的100個字節的文件。
// 傳入0則會清空文件。

 err := os.Truncate("test.txt",100)
iferr !=nil{
 log.Fatal(err)
 }
}

得到文件信息

packagemain

import(
"fmt"
"log"
"os"
)

var(
 fileInfo os.FileInfo
 err error
)

funcmain() {
// 如果文件不存在，則返回錯誤
 fileInfo, err = os.Stat("test.txt")
iferr !=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())
}

重命名和移動

packagemain

import(
"log"
"os"
)

funcmain() {
 originalPath := "test.txt"
 newPath := "test2.txt"
 err := os.Rename(originalPath, newPath)
iferr !=nil{
 log.Fatal(err)
 }
}

譯者按： rename 和 move 原理一樣

刪除文件

packagemain

import(
"log"
"os"
)

funcmain() {
 err := os.Remove("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
}

打開和關閉文件

packagemain

import(
"log"
"os"
)

funcmain() {
// 簡單地以只讀的方式打開。下面的例子會介紹讀寫的例子。
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
 file.Close()

// OpenFile提供更多的選項。
// 最后一個參數是權限模式permission mode
// 第二個是打開時的屬性 
 file, err = os.OpenFile("test.txt", os.O_APPEND,0666)
iferr !=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的方式打開
}

譯者按：熟悉Linux的讀者應該很熟悉權限模式，通過Linux命令 chmod 可以更改文件的權限

檢查文件是否存在

packagemain

import(
"log"
"os"
)

var(
 fileInfo *os.FileInfo
 err error
)

funcmain() {
// 文件不存在則返回error
 fileInfo, err := os.Stat("test.txt")
iferr !=nil{
ifos.IsNotExist(err) {
 log.Fatal("File does not exist.")
 }
 }
 log.Println("File does exist. File information:")
 log.Println(fileInfo)
}

檢查讀寫權限

packagemain

import(
"log"
"os"
)

funcmain() {
// 這個例子測試寫權限，如果沒有寫權限則返回error。
// 注意文件不存在也會返回error，需要檢查error的信息來獲取到底是哪個錯誤導致。
 file, err := os.OpenFile("test.txt", os.O_WRONLY,0666)
iferr !=nil{
ifos.IsPermission(err) {
 log.Println("Error: Write permission denied.")
 }
 }
 file.Close()

// 測試讀權限
 file, err = os.OpenFile("test.txt", os.O_RDONLY,0666)
iferr !=nil{
ifos.IsPermission(err) {
 log.Println("Error: Read permission denied.")
 }
 }
 file.Close()
}

改變權限、擁有者、時間戳

packagemain

import(
"log"
"os"
"time"
)

funcmain() {
// 使用Linux風格改變文件權限
 err := os.Chmod("test.txt",0777)
iferr !=nil{
 log.Println(err)
 }

// 改變文件所有者
 err = os.Chown("test.txt", os.Getuid(), os.Getgid())
iferr !=nil{
 log.Println(err)
 }

// 改變時間戳
 twoDaysFromNow := time.Now().Add(48* time.Hour)
 lastAccessTime := twoDaysFromNow
 lastModifyTime := twoDaysFromNow
 err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
iferr !=nil{
 log.Println(err)
 }
}

硬鏈接和軟鏈接

一個普通的文件是一個指向硬盤的inode的地方。

硬鏈接創建一個新的指針指向同一個地方。只有所有的鏈接被刪除后文件才會被刪除。硬鏈接只在相同的文件系統中才工作。你可以認為一個硬鏈接是一個正常的鏈接。

symbolic link，又叫軟連接，和硬鏈接有點不一樣，它不直接指向硬盤中的相同的地方，而是通過名字引用其它文件。他們可以指向不同的文件系統中的不同文件。并不是所有的操作系統都支持軟鏈接。

packagemain

import(
"os"
"log"
"fmt"
)

funcmain() {
// 創建一個硬鏈接。
// 創建后同一個文件內容會有兩個文件名，改變一個文件的內容會影響另一個。
// 刪除和重命名不會影響另一個。
 err := os.Link("original.txt","original_also.txt")
iferr !=nil{
 log.Fatal(err)
 }

 fmt.Println("creating sym")
// Create a symlink
 err = os.Symlink("original.txt","original_sym.txt")
iferr !=nil{
 log.Fatal(err)
 }

// Lstat返回一個文件的信息，但是當文件是一個軟鏈接時，它返回軟鏈接的信息，而不是引用的文件的信息。
// Symlink在Windows中不工作。
 fileInfo, err := os.Lstat("original_sym.txt")
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Link info: %+v", fileInfo)

//改變軟鏈接的擁有者不會影響原始文件。
 err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
iferr !=nil{
 log.Fatal(err)
 }
}

讀寫

復制文件

packagemain

import(
"os"
"log"
"io"
)

funcmain() {
// 打開原始文件
 originalFile, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
deferoriginalFile.Close()

// 創建新的文件作為目標文件
 newFile, err := os.Create("test_copy.txt")
iferr !=nil{
 log.Fatal(err)
 }
defernewFile.Close()

// 從源中復制字節到目標文件
 bytesWritten, err := io.Copy(newFile, originalFile)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Copied %d bytes.", bytesWritten)

// 將文件內容flush到硬盤中
 err = newFile.Sync()
iferr !=nil{
 log.Fatal(err)
 }
}

跳轉到文件指定位置(Seek)

packagemain

import(
"os"
"fmt"
"log"
)

funcmain() {
 file, _ := os.Open("test.txt")
deferfile.Close()

// 偏離位置，可以是正數也可以是負數
varoffsetint64=5

// 用來計算offset的初始位置
// 0 = 文件開始位置
// 1 = 當前位置
// 2 = 文件結尾處
varwhenceint=0
 newPosition, err := file.Seek(offset, whence)
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Println("Just moved to 5:", newPosition)

// 從當前位置回退兩個字節
 newPosition, err = file.Seek(-2,1)
iferr !=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)
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Println("Position after seeking 0,0:", newPosition)
}

寫文件

可以使用 os 包寫入一個打開的文件。

因為Go可執行包是靜態鏈接的可執行文件，你import的每一個包都會增加你的可執行文件的大小。其它的包如 io 、｀ioutil｀、｀bufio｀提供了一些方法，但是它們不是必須的。

packagemain

import(
"os"
"log"
)

funcmain() {
// 可寫方式打開文件
 file, err := os.OpenFile(
"test.txt",
 os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
 0666,
 )
iferr !=nil{
 log.Fatal(err)
 }
deferfile.Close()

// 寫字節到文件中
 byteSlice := []byte("Bytes!\n")
 bytesWritten, err := file.Write(byteSlice)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Wrote %d bytes.\n", bytesWritten)
}

快寫文件

ioutil 包有一個非常有用的方法 WriteFile() 可以處理創建／打開文件、寫字節slice和關閉文件一系列的操作。如果你需要簡潔快速地寫字節slice到文件中，你可以使用它。

packagemain

import(
"io/ioutil"
"log"
)

funcmain() {
 err := ioutil.WriteFile("test.txt", []byte("Hi\n"),0666)
iferr !=nil{
 log.Fatal(err)
 }
}

使用緩存寫

bufio 包提供了帶緩存功能的writer，所以你可以在寫字節到硬盤前使用內存緩存。當你處理很多的數據很有用，因為它可以節省操作硬盤I/O的時間。在其它一些情況下它也很有用，比如你每次寫一個字節，把它們攢在內存緩存中，然后一次寫入到硬盤中，減少硬盤的磨損以及提升性能。

packagemain

import(
"log"
"os"
"bufio"
)

funcmain() {
// 打開文件，只寫
 file, err := os.OpenFile("test.txt", os.O_WRONLY,0666)
iferr !=nil{
 log.Fatal(err)
 }
deferfile.Close()

// 為這個文件創建buffered writer
 bufferedWriter := bufio.NewWriter(file)

// 寫字節到buffer
 bytesWritten, err := bufferedWriter.Write(
 []byte{65,66,67},
 )
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Bytes written: %d\n", bytesWritten)

// 寫字符串到buffer
// 也可以使用 WriteRune() 和 WriteByte() 
 bytesWritten, err = bufferedWriter.WriteString(
"Buffered string\n",
 )
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Bytes written: %d\n", bytesWritten)

// 檢查緩存中的字節數
 unflushedBufferSize := bufferedWriter.Buffered()
 log.Printf("Bytes buffered: %d\n", unflushedBufferSize)

// 還有多少字節可用（未使用的緩存大小）
 bytesAvailable := bufferedWriter.Available()
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Available buffer: %d\n", bytesAvailable)

// 寫內存buffer到硬盤
 bufferedWriter.Flush()

// 丟棄還沒有flush的緩存的內容，清除錯誤并把它的輸出傳給參數中的writer
// 當你想將緩存傳給另外一個writer時有用
 bufferedWriter.Reset(bufferedWriter)

 bytesAvailable = bufferedWriter.Available()
iferr !=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()
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Available buffer: %d\n", bytesAvailable)
}

讀取最多N個字節

os.File 提供了文件操作的基本功能， 而 io 、 ioutil 、 bufio 提供了額外的輔助函數。

packagemain

import(
"os"
"log"
)

funcmain() {
// 打開文件，只讀
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
deferfile.Close()

// 從文件中讀取len(b)字節的文件。
// 返回0字節意味著讀取到文件尾了
// 讀取到文件會返回io.EOF的error
 byteSlice := make([]byte,16)
 bytesRead, err := file.Read(byteSlice)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Number of bytes read: %d\n", bytesRead)
 log.Printf("Data read: %s\n", byteSlice)
}

讀取正好N個字節

packagemain

import(
"os"
"log"
"io"
)

funcmain() {
// Open file for reading
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }

// file.Read()可以讀取一個小文件到大的byte slice中，
// 但是io.ReadFull()在文件的字節數小于byte slice字節數的時候會返回錯誤
 byteSlice := make([]byte,2)
 numBytesRead, err := io.ReadFull(file, byteSlice)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Number of bytes read: %d\n", numBytesRead)
 log.Printf("Data read: %s\n", byteSlice)
}

讀取至少N個字節

packagemain

import(
"os"
"log"
"io"
)

funcmain() {
// 打開文件，只讀
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }

 byteSlice := make([]byte,512)
 minBytes :=8
// io.ReadAtLeast()在不能得到最小的字節的時候會返回錯誤，但會把已讀的文件保留
 numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Number of bytes read: %d\n", numBytesRead)
 log.Printf("Data read: %s\n", byteSlice)
}

讀取全部字節

packagemain

import(
"os"
"log"
"fmt"
"io/ioutil"
)

funcmain() {
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }

// os.File.Read(), io.ReadFull() 和
// io.ReadAtLeast() 在讀取之前都需要一個固定大小的byte slice。
// 但ioutil.ReadAll()會讀取reader(這個例子中是file)的每一個字節，然后把字節slice返回。
 data, err := ioutil.ReadAll(file)
iferr !=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))
}

快讀到內存

packagemain

import(
"log"
"io/ioutil"
)

funcmain() {
// 讀取文件到byte slice中
 data, err := ioutil.ReadFile("test.txt")
iferr !=nil{
 log.Fatal(err)
 }

 log.Printf("Data read: %s\n", data)
}

使用緩存讀

有緩存寫也有緩存讀。

緩存reader會把一些內容緩存在內存中。它會提供比 os.File 和 io.Reader 更多的函數,缺省的緩存大小是4096，最小緩存是16。

packagemain

import(
"os"
"log"
"bufio"
"fmt"
)

funcmain() {
// 打開文件，創建buffered reader
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
 bufferedReader := bufio.NewReader(file)

// 得到字節，當前指針不變
 byteSlice := make([]byte,5)
 byteSlice, err = bufferedReader.Peek(5)
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Peeked at 5 bytes: %s\n", byteSlice)

// 讀取，指針同時移動
 numBytesRead, err := bufferedReader.Read(byteSlice)
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)

// 讀取一個字節, 如果讀取不成功會返回Error
 myByte, err := bufferedReader.ReadByte()
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Read 1 byte: %c\n", myByte)

// 讀取到分隔符，包含分隔符，返回byte slice
 dataBytes, err := bufferedReader.ReadBytes('\n')
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Read bytes: %s\n", dataBytes)

// 讀取到分隔符，包含分隔符，返回字符串
 dataString, err := bufferedReader.ReadString('\n')
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Printf("Read string: %s\n", dataString)

//這個例子讀取了很多行，所以test.txt應該包含多行文本才不至于出錯
}

使用 scanner

Scanner 是 bufio 包下的類型,在處理文件中以分隔符分隔的文本時很有用。

通常我們使用換行符作為分隔符將文件內容分成多行。在CSV文件中，逗號一般作為分隔符。

os.File 文件可以被包裝成 bufio.Scanner ，它就像一個緩存reader。

我們會調用 Scan() 方法去讀取下一個分隔符，使用 Text() 或者 Bytes() 獲取讀取的數據。

分隔符可以不是一個簡單的字節或者字符，有一個特殊的方法可以實現分隔符的功能，以及將指針移動多少，返回什么數據。

如果沒有定制的 SplitFunc 提供，缺省的 ScanLines 會使用 newline 字符作為分隔符，其它的分隔函數還包括 ScanRunes 和 ScanWords ,皆在 bufio 包中。

// To define your own split function, match this fingerprint
typeSplitFuncfunc(data []byte, atEOFbool) (advanceint, token []byte, err error)

// Returning (0, nil, nil) will tell the scanner
// to scan again, but with a bigger buffer because
// it wasn't enough data to reach the delimiter

下面的例子中，為一個文件創建了 bufio.Scanner ，并按照單詞逐個讀取：

packagemain

import(
"os"
"log"
"fmt"
"bufio"
)

funcmain() {
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
 scanner := bufio.NewScanner(file)

// 缺省的分隔函數是bufio.ScanLines,我們這里使用ScanWords。
// 也可以定制一個SplitFunc類型的分隔函數
 scanner.Split(bufio.ScanWords)

// scan下一個token.
 success := scanner.Scan()
ifsuccess ==false{
// 出現錯誤或者EOF是返回Error
 err = scanner.Err()
iferr ==nil{
 log.Println("Scan completed and reached EOF")
 } else{
 log.Fatal(err)
 }
 }

// 得到數據，Bytes() 或者 Text()
 fmt.Println("First word found:", scanner.Text())

// 再次調用scanner.Scan()發現下一個token
}

壓縮

打包(zip) 文件

// This example uses zip but standard library
// also supports tar archives
packagemain

import(
"archive/zip"
"log"
"os"
)

funcmain() {
// 創建一個打包文件
 outFile, err := os.Create("test.zip")
iferr !=nil{
 log.Fatal(err)
 }
deferoutFile.Close()

// 創建zip writer
 zipWriter := zip.NewWriter(outFile)


// 往打包文件中寫文件。
// 這里我們使用硬編碼的內容，你可以遍歷一個文件夾，把文件夾下的文件以及它們的內容寫入到這個打包文件中。
varfilesToArchive = []struct{
 Name, Body string
 } {
 {"test.txt","String contents of file"},
 {"test2.txt","\x61\x62\x63\n"},
 }

// 下面將要打包的內容寫入到打包文件中，依次寫入。
for_, file :=rangefilesToArchive {
 fileWriter, err := zipWriter.Create(file.Name)
iferr !=nil{
 log.Fatal(err)
 }
 _, err = fileWriter.Write([]byte(file.Body))
iferr !=nil{
 log.Fatal(err)
 }
 }

// 清理
 err = zipWriter.Close()
iferr !=nil{
 log.Fatal(err)
 }
}

抽取(unzip) 文件

// This example uses zip but standard library
// also supports tar archives
packagemain

import(
"archive/zip"
"log"
"io"
"os"
"path/filepath"
)

funcmain() {
 zipReader, err := zip.OpenReader("test.zip")
iferr !=nil{
 log.Fatal(err)
 }
deferzipReader.Close()

// 遍歷打包文件中的每一文件/文件夾
for_, file :=rangezipReader.Reader.File {
// 打包文件中的文件就像普通的一個文件對象一樣
 zippedFile, err := file.Open()
iferr !=nil{
 log.Fatal(err)
 }
deferzippedFile.Close()

// 指定抽取的文件名。
// 你可以指定全路徑名或者一個前綴，這樣可以把它們放在不同的文件夾中。
// 我們這個例子使用打包文件中相同的文件名。
 targetDir := "./"
 extractedFilePath := filepath.Join(
 targetDir,
 file.Name,
 )

// 抽取項目或者創建文件夾
iffile.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(),
 )
iferr !=nil{
 log.Fatal(err)
 }
deferoutputFile.Close()

// 通過io.Copy簡潔地復制文件內容
 _, err = io.Copy(outputFile, zippedFile)
iferr !=nil{
 log.Fatal(err)
 }
 }
 }
}

壓縮文件

// 這個例子中使用gzip壓縮格式，標準庫還支持zlib, bz2, flate, lzw
packagemain

import(
"os"
"compress/gzip"
"log"
)

funcmain() {
 outputFile, err := os.Create("test.txt.gz")
iferr !=nil{
 log.Fatal(err)
 }

 gzipWriter := gzip.NewWriter(outputFile)
defergzipWriter.Close()

// 當我們寫如到gizp writer數據時，它會依次壓縮數據并寫入到底層的文件中。
// 我們不必關心它是如何壓縮的，還是像普通的writer一樣操作即可。
 _, err = gzipWriter.Write([]byte("Gophers rule!\n"))
iferr !=nil{
 log.Fatal(err)
 }

 log.Println("Compressed data written to file.")
}

解壓縮文件

// 這個例子中使用gzip壓縮格式，標準庫還支持zlib, bz2, flate, lzw
packagemain

import(
"compress/gzip"
"log"
"io"
"os"
)

funcmain() {
// 打開一個gzip文件。
// 文件是一個reader,但是我們可以使用各種數據源，比如web服務器返回的gzipped內容，
// 它的內容不是一個文件，而是一個內存流
 gzipFile, err := os.Open("test.txt.gz")
iferr !=nil{
 log.Fatal(err)
 }

 gzipReader, err := gzip.NewReader(gzipFile)
iferr !=nil{
 log.Fatal(err)
 }
defergzipReader.Close()

// 解壓縮到一個writer,它是一個file writer
 outfileWriter, err := os.Create("unzipped.txt")
iferr !=nil{
 log.Fatal(err)
 }
deferoutfileWriter.Close()

// 復制內容
 _, err = io.Copy(outfileWriter, gzipReader)
iferr !=nil{
 log.Fatal(err)
 }
}

其它

臨時文件和目錄

ioutil 提供了兩個函數: TempDir() 和 TempFile() 。

使用完畢后，調用者負責刪除這些臨時文件和文件夾。

有一點好處就是當你傳遞一個空字符串作為文件夾名的時候，它會在操作系統的臨時文件夾中創建這些項目（/tmp on Linux）。

os.TempDir() 返回當前操作系統的臨時文件夾。

packagemain

import(
"os"
"io/ioutil"
"log"
"fmt"
)

funcmain() {
// 在系統臨時文件夾中創建一個臨時文件夾
 tempDirPath, err := ioutil.TempDir("","myTempDir")
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Println("Temp dir created:", tempDirPath)

// 在臨時文件夾中創建臨時文件
 tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
iferr !=nil{
 log.Fatal(err)
 }
 fmt.Println("Temp file created:", tempFile.Name())

// ... 做一些操作 ...

// 關閉文件
 err = tempFile.Close()
iferr !=nil{
 log.Fatal(err)
 }

// 刪除我們創建的資源
 err = os.Remove(tempFile.Name())
iferr !=nil{
 log.Fatal(err)
 }
 err = os.Remove(tempDirPath)
iferr !=nil{
 log.Fatal(err)
 }
}

通過HTTP下載文件

packagemain

import(
"os"
"io"
"log"
"net/http"
)

funcmain() {
 newFile, err := os.Create("devdungeon.html")
iferr !=nil{
 log.Fatal(err)
 }
defernewFile.Close()

 url := "http://www.devdungeon.com/archive"
 response, err := http.Get(url)
deferresponse.Body.Close()

// 將HTTP response Body中的內容寫入到文件
// Body滿足reader接口，因此我們可以使用ioutil.Copy
 numBytesWritten, err := io.Copy(newFile, response.Body)
iferr !=nil{
 log.Fatal(err)
 }
 log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}

哈希和摘要

packagemain

import(
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"log"
"fmt"
"io/ioutil"
)

funcmain() {
// 得到文件內容
 data, err := ioutil.ReadFile("test.txt")
iferr !=nil{
 log.Fatal(err)
 }

// 計算Hash
 fmt.Printf("Md5: %x\n\n", md5.Sum(data))
 fmt.Printf("Sha1: %x\n\n", sha1.Sum(data))
 fmt.Printf("Sha256: %x\n\n", sha256.Sum256(data))
 fmt.Printf("Sha512: %x\n\n", sha512.Sum512(data))
}

上面的例子復制整個文件內容到內存中，傳遞給hash函數。

另一個方式是創建一個hash writer, 使用 Write 、 WriteString 、 Copy 將數據傳給它。

下面的例子使用 md5 hash,但你可以使用其它的Writer。

packagemain

import(
"crypto/md5"
"log"
"fmt"
"io"
"os"
)

funcmain() {
 file, err := os.Open("test.txt")
iferr !=nil{
 log.Fatal(err)
 }
deferfile.Close()

//創建一個新的hasher,滿足writer接口
 hasher := md5.New()
 _, err = io.Copy(hasher, file)
iferr !=nil{
 log.Fatal(err)
 }

// 計算hash并打印結果。
// 傳遞 nil 作為參數，因為我們不通參數傳遞數據，而是通過writer接口。
 sum := hasher.Sum(nil)
 fmt.Printf("Md5 checksum: %x\n", sum)
}

 

來自：http://colobu.com/2016/10/12/go-file-operations/