Go檔案操作大全

阿新 • • 發佈：2020-12-16

Go檔案操作大全

介紹

萬物皆檔案

UNIX 的一個基礎設計就是"萬物皆檔案"(everything is a file)。我們不必知道一個檔案到底對映成什麼，作業系統的裝置驅動抽象成檔案。作業系統為裝置提供了檔案格式的介面。

Go語言中的reader和writer介面也類似。我們只需簡單的讀寫位元組，不必知道reader的資料來自哪裡，也不必知道writer將資料傳送到哪裡。
你可以在/dev下檢視可用的裝置，有些可能需要較高的許可權才能訪問。

基本操作

建立空檔案

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()
}

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"
)

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"
)

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

譯者按： rename 和 move 原理一樣

刪除檔案

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() {
    // 簡單地以只讀的方式開啟。下面的例子會介紹讀寫的例子。
    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的方式開啟
}

譯者按：熟悉Linux的讀者應該很熟悉許可權模式，通過Linux命令chmod可以更改檔案的許可權
https://www.linux.com/learn/understanding-linux-file-permissions

補充了原文未介紹的flag

檢查檔案是否存在

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() {
    // 這個例子測試寫許可權，如果沒有寫許可權則返回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)
    }
}

硬連結和軟連結

一個普通的檔案是一個指向硬碟的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)
    }
}

讀寫

複製檔案

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)
}

寫檔案

可以使用os包寫入一個開啟的檔案。
因為Go可執行包是靜態連結的可執行檔案，你import的每一個包都會增加你的可執行檔案的大小。其它的包如io、ioutil、bufio提供了一些方法，但是它們不是必須的。

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應該包含多行文字才不至於出錯
}

使用 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
type SplitFunc func(data []byte, atEOF bool) (advance int, 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，並按照單詞逐個讀取：

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
}

壓縮

打包(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)
    }
}

其它

臨時檔案和目錄

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)
    }
}

通過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)
}

雜湊和摘要

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)
}

Go檔案操作大全

Go檔案操作大全

介紹

萬物皆檔案

基本操作

建立空檔案

Truncate檔案

得到檔案資訊

重新命名和移動

刪除檔案

開啟和關閉檔案

檢查檔案是否存在

檢查讀寫許可權

改變許可權、擁有者、時間戳

硬連結和軟連結

讀寫

複製檔案

跳轉到檔案指定位置(Seek)

寫檔案

快寫檔案

使用快取寫

讀取最多N個位元組

讀取正好N個位元組

讀取至少N個位元組

讀取全部位元組

快讀到記憶體

使用快取讀

使用 scanner

壓縮

打包(zip) 檔案

抽取(unzip) 檔案

壓縮檔案

解壓縮檔案

其它

臨時檔案和目錄

通過HTTP下載檔案

雜湊和摘要

相關推薦