1.文件基本操作
1.1創建空文件
package main
import (
"os"
"log"
)
var (
newFile *os.File
err error
)
func main(){
//創建文件
newFile,err=os.Create("text.txt")
checkErr(err)
log.Println(newFile)
newFile.Close()
}
/**
檢查錯誤
*/
func checkErr(err error){
if err!=nil{
log.Fatal(err)
}
}1.2 truncate 文件
package main
import (
"log"
"os"
)
func main(){
// 裁剪一個文件到100個字節。
// 如果文件本來就少於100個字節，則文件中原始內容得以保留，剩餘的字節以null字節填充。
// 如果文件本來超過100個字節，則超過的字節會被拋棄。
// 這樣我們總是得到精確的100個字節的文件。
// 傳入0則會清空文件。
err:=os.Truncate("text.txt",100)
checkErr(err)
}
func checkErr(err error){
if err!=nil{
log.Panic(err)
}
}1.3 得到文件信息
package main
import (
"log"
"os"
"fmt"
)
var (
fileInfo os.FileInfo
err error
)
func main() {
fileInfo, err = os.Stat("text.txt")
checkErr(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())
}
func checkErr(err error) {
if err != nil {
log.Panic(err)
}
}
運行結果
1.4 重命名和移動
rename和move原理一樣
package main
import (
"log"
"os"
)
func main() {
oldPath, newPath := "text.txt", "test.txt"
err := os.Rename(oldPath, newPath)
checkErr(err)
}
func checkErr(err error) {
if err != nil {
log.Panic(err)
}
}1.5 刪除文件
package main
import (
"log"
"os"
)
func main() {
err := os.Remove("text.txt")
checkErr(err)
}
func checkErr(err error) {
if err != nil {
log.Panic(err)
}
}
1.6 打開文件
package main
import (
"log"
"os"
)
func main() {
// 簡單地以只讀的方式打開。下面的例子會介紹讀寫的例子。
file,err:=os.Open("test.txt")
checkErr(err)
file.Close()
// OpenFile提供更多的選項。
// 最後一個參數是權限模式permission mode
// 第二個是打開時的屬性
file1,err:=os.OpenFile("hello.txt",os.O_CREATE|os.O_APPEND,0666)
checkErr(err)
file1.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的方式打開
}
func checkErr(err error) {
if err != nil {
log.Panic(err)
}
}
1.7檢查文件是否存在
package main
import (
"log"
"os"
)
func main() {
fileInfo,err:=os.Stat("hello.txt")
if err!=nil{
if os.IsNotExist(err){
log.Fatalln("file does not exist")
}
}
log.Println("file does exist. file information:")
log.Println(fileInfo)
}
1.8 檢查讀寫權限
package main
import (
"os"
"log"
)
func main() {
// 這個例子測試寫權限，如果沒有寫權限則返回error。
// 注意文件不存在也會返回error，需要檢查error的信息來獲取到底是哪個錯誤導致。
file, err := os.OpenFile("1.txt", os.O_WRONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error write permission denied")
}
if os.IsNotExist(err) {
log.Println("file does not exist")
}
}
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()
}
1.9改變權限、擁有者、時間戳
package main
import (
"os"
"log"
"time"
"fmt"
)
func main(){
// 使用Linux風格改變文件權限
err:=os.Chmod("test.txt",0777)
checkErr(err)
// 改變文件所有者
err=os.Chown("test.txt",os.Geteuid(),os.Getgid())
checkErr(err)
twoDaysFromNow:=time.Now().Add(48*time.Hour)
lastAccessTime:=twoDaysFromNow
lastModifyTime:=twoDaysFromNow
err=os.Chtimes("test.txt",lastAccessTime,lastModifyTime)
checkErr(err)
fileInfo,err:=os.Stat("test.txt")
fmt.Println("file modified time:",fileInfo.ModTime())
}
func checkErr(err error){
if err!=nil{
log.Println(err)
}
}1.10 硬鏈接和軟鏈接
一個普通的文件是一個指向硬盤的inode的地方。
硬鏈接創建一個新的指針指向同一個地方。只有所有的鏈接被刪除後文件纔會被刪除。硬鏈接只在相同的文件系統中才工作。你可以認爲一個硬鏈接是一個正常的鏈接。symbolic link，又叫軟連接，和硬鏈接有點不一樣，它不直接指向硬盤中的相同的地方，而是通過名字引用其它文件。他們可以指向不同的文件系統中的不同文件。並不是所有的操作系統都支持軟鏈接。
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)
}
}文件讀寫
1.1 複製文件
package main
import (
"os"
"log"
"io"
)
func main(){
//打開原始文件
originalFile,err:=os.Open("test.txt")
checkErr(err)
defer originalFile.Close()
//創建新的文件作爲目標文件
newFile,err:=os.Create("test_copy.txt")
checkErr(err)
defer newFile.Close()
//從源中複製字節到目標文件
bytesWritten,err:=io.Copy(newFile,originalFile)
checkErr(err)
log.Printf("copied %d bytes.",bytesWritten)
// 將文件內容flush到硬盤中，好像沒有這一步也可以
err=newFile.Sync()
checkErr(err)
}
func checkErr(err error){
if err!=nil{
log.Fatal(err)
}
}1.2 跳轉到文件指定位置(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)
}1.3 寫文件
可以使用os包寫入一個打開的文件。
因爲Go可執行包是靜態鏈接的可執行文件，你import的每一個包都會增加你的可執行文件的大小。其它的包如io、ioutil、bufio提供了一些方法，但是它們不是必須的。
package main
import (
"os"
"log"
)
func main() {
//可寫方式打開文件
file, err := os.OpenFile("test.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
checkErr(err)
defer file.Close()
//寫字節到文件中
byteSlice := []byte("Bytes!\n")
bytesWritten, err := file.Write(byteSlice)
checkErr(err)
log.Printf("wrote %d bytes.\n", bytesWritten)
}
func checkErr(err error) {
if err != nil {
log.Println(err)
}
}
1.4 快寫文件
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)
}
}1.5 使用緩存寫
bufio包提供了帶緩存功能的writer，所以你可以在寫字節到硬盤前使用內存緩存。當你處理很多的數據很有用，因爲它可以節省操作硬盤I/O的時間。在其它一些情況下它也很有用，比如你每次寫一個字節，把它們攢在內存緩存中，然後一次寫入到硬盤中，減少硬盤的磨損以及提升性能。
package main
import (
"os"
"log"
"bufio"
)
func main() {
//可寫方式打開文件
file,err:=os.OpenFile("test.txt",os.O_WRONLY,0666)
checkErr(err)
defer file.Close()
//爲這個文件創建buffered writer
bufferdWriter:=bufio.NewWriter(file)
//寫自己到buf 中
bytesWritten,err:=bufferdWriter.Write([]byte{65,66,67})
checkErr(err)
log.Printf("Bytes written:%d\n",bytesWritten)
//寫字符串到buffer
//也可以使用writeRune() 和 WriteByte()
bytesWritten,err=bufferdWriter.WriteString("Buffered string\n")
checkErr(err)
log.Printf("bytes buffered:%d\n",bytesWritten)
//檢查緩存中的字節數
unflushedBufferSize:=bufferdWriter.Buffered()
log.Printf("Bytes buffered:%d\n",unflushedBufferSize)
//還有多少字節可用（未使用的緩存大小）
bytesAvailable:=bufferdWriter.Available()
log.Printf("available buffer:%d\n",bytesAvailable)
// 寫內存buffer到硬盤
bufferdWriter.Flush()
// 丟棄還沒有flush的緩存的內容，清除錯誤並把它的輸出傳給參數中的writer
// 當你想將緩存傳給另外一個writer時有用
bufferdWriter.Reset(bufferdWriter)
bytesAvailable=bufferdWriter.Available()
checkErr(err)
log.Printf("available buffer:%d\n",bytesAvailable)
// 重新設置緩存的大小。
// 第一個參數是緩存應該輸出到哪裏，這個例子中我們使用相同的writer。
// 如果我們設置的新的大小小於第一個參數writer的緩存大小， 比如10，我們不會得到一個10字節大小的緩存，
// 而是writer的原始大小的緩存，默認是4096。
// 它的功能主要還是爲了擴容。
bufio.NewWriterSize(bufferdWriter,8000)
bytesAvailable= bufferdWriter.Available()
log.Printf("available buff:%d\n",bytesAvailable)
}
func checkErr(err error) {
if err != nil {
log.Println(err)
}
}
1.6 讀取最多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)
}1.7 讀取正好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)
}1.8讀取至少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)
}1.9讀取全部字節
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))
}1.10快讀到內存
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)
}1.11 使用緩存讀
有緩存寫也有緩存讀。
緩存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應該包含多行文本才不至於出錯
}3.12 使用scanner
Scanner是bufio包下的類型,在處理文件中以分隔符分隔的文本時很有用。
通常我們使用換行符作爲分隔符將文件內容分成多行。在CSV文件中，逗號一般作爲分隔符。
os.File文件可以被包裝成bufio.Scanner，它就像一個緩存reader。
我們會調用Scan()方法去讀取下一個分隔符，使用Text()或者Bytes()獲取讀取的數據。分隔符可以不是一個簡單的字節或者字符，有一個特殊的方法可以實現分隔符的功能，以及將指針移動多少，返回什麼數據。
如果沒有定製的SplitFunc提供，缺省的ScanLines會使用newline字符作爲分隔符，其它的分隔函數還包括ScanRunes和ScanWords,皆在bufio包中。
package main
import (
"os"
"log"
"fmt"
"bufio"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
scanner := bufio.NewScanner(file)
// 缺省的分隔函數是bufio.ScanLines,我們這裏使用ScanWords。
// 也可以定製一個SplitFunc類型的分隔函數
scanner.Split(bufio.ScanWords)
// scan下一個token.
success := scanner.Scan()
if success == false {
// 出現錯誤或者EOF是返回Error
err = scanner.Err()
if err == nil {
log.Println("Scan completed and reached EOF")
} else {
log.Fatal(err)
}
}
// 得到數據，Bytes() 或者 Text()
fmt.Println("First word found:", scanner.Text())
// 再次調用scanner.Scan()發現下一個token
}1.打包文件
// 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)
}
}2.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)
}
}
}
}3.壓縮文件
// 這個例子中使用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.")
}4.解壓縮文件
// 這個例子中使用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)
}
}5.臨時文件和目錄
ioutil提供了兩個函數: TempDir() 和 TempFile()。
使用完畢後，調用者負責刪除這些臨時文件和文件夾。
有一點好處就是當你傳遞一個空字符串作爲文件夾名的時候，它會在操作系統的臨時文件夾中創建這些項目（/tmp on Linux）。
os.TempDir()返回當前操作系統的臨時文件夾。
package main
import (
"os"
"io/ioutil"
"log"
"fmt"
)
func main() {
// 在系統臨時文件夾中創建一個臨時文件夾
tempDirPath, err := ioutil.TempDir("", "myTempDir")
if err != nil {
log.Fatal(err)
}
fmt.Println("Temp dir created:", tempDirPath)
// 在臨時文件夾中創建臨時文件
tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("Temp file created:", tempFile.Name())
// ... 做一些操作 ...
// 關閉文件
err = tempFile.Close()
if err != nil {
log.Fatal(err)
}
// 刪除我們創建的資源
err = os.Remove(tempFile.Name())
if err != nil {
log.Fatal(err)
}
err = os.Remove(tempDirPath)
if err != nil {
log.Fatal(err)
}
}6.通過HTTP下載文件
package main
import (
"os"
"io"
"log"
"net/http"
)
func main() {
newFile, err := os.Create("devdungeon.html")
if err != nil {
log.Fatal(err)
}
defer newFile.Close()
url := "http://www.devdungeon.com/archive"
response, err := http.Get(url)
defer response.Body.Close()
// 將HTTP response Body中的內容寫入到文件
// Body滿足reader接口，因此我們可以使用ioutil.Copy
numBytesWritten, err := io.Copy(newFile, response.Body)
if err != nil {
log.Fatal(err)
}
log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}7.哈希和摘要
package main
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"log"
"fmt"
"io/ioutil"
)
func main() {
// 得到文件內容
data, err := ioutil.ReadFile("test.txt")
if err != 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。
package main
import (
"crypto/md5"
"log"
"fmt"
"io"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
//創建一個新的hasher,滿足writer接口
hasher := md5.New()
_, err = io.Copy(hasher, file)
if err != nil {
log.Fatal(err)
}
// 計算hash並打印結果。
// 傳遞 nil 作爲參數，因爲我們不通參數傳遞數據，而是通過writer接口。
sum := hasher.Sum(nil)
fmt.Printf("Md5 checksum: %x\n", sum)
}