Go文件操作大全

原創 scloudrun 2018-08-26 04:57

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

原文: Working with Files in Go, 作者: NanoDano

介紹

萬物皆文件

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

Go語言中的reader和writer接口也類似。我們只需簡單的讀寫字節，不必知道reader的數據來自哪裏，也不必知道writer將數據發送到哪裏。
你可以在/dev下查看可用的設備，有些可能需要較高的權限才能訪問。

基本操作

創建空文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
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文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
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)
    }
}

得到文件信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
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())
}

重命名和移動

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
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 原理一樣

刪除文件

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package main
import (
    "log"
    "os"
)
func main() {
    err := os.Remove("test.txt")
    if err != nil {
        log.Fatal(err)
    }
}

打開和關閉文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
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

檢查文件是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
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)
}

檢查讀寫權限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
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()
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
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，又叫軟連接，和硬鏈接有點不一樣，它不直接指向硬盤中的相同的地方，而是通過名字引用其它文件。他們可以指向不同的文件系統中的不同文件。並不是所有的操作系統都支持軟鏈接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
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｀提供了一些方法，但是它們不是必須的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
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到文件中，你可以使用它。

1
2
3
4
5
6
7
8
9
10
11
12
13
 
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的時間。在其它一些情況下它也很有用，比如你每次寫一個字節，把它們攢在內存緩存中，然後一次寫入到硬盤中，減少硬盤的磨損以及提升性能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
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提供了額外的輔助函數。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
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個字節

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
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個字節

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
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包中。

1
2
3
4
5
6
 
// 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，並按照單詞逐個讀取：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
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) 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
// 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) 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
// 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)
            }
        }
    }
}

壓縮文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
// 這個例子中使用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.")
}

解壓縮文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
// 這個例子中使用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()返回當前操作系統的臨時文件夾。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
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下載文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
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)
}

哈希和摘要

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
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)
}

文章來源 http://colobu.com/2016/10/12/go-file-operations/  一個非常好的個人技術blog
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

go 多平臺交叉編譯

 獲取gox工具 go get github.com/mitchellh/gox 使用 多平臺 gox Number of parallel builds: 4 --> darwin/386: github.com/mit

takujo 2020-07-08 10:41:49

【轉】gophercloud 不錯的openstack golang sdk

  原文: https://www.cnblogs.com/rongfengliang/p/14069237.html ---------------------------   gophercloud 是一個基於golang 包裝的op

牛頓的小腦 2021-08-19 13:34:53

go c nodejs csharp 可能不太準確的性能測試

斐波那契數列 (百度百科) 斐波那契數列（Fibonacci sequence），又稱黃金分割數列、因數學家列昂納多·斐波那契（Leonardoda Fibonacci）以兔子繁殖爲例子而引入，故又稱爲“兔子數列”，指的是這樣一個

whitehack 2020-07-08 12:33:27

php+go實現grpc

1.先安裝編譯器:https://github.com/google/protobuf/releases把bin下的exe放到環境PATH目錄。做成環境變量. 2.獲取go支持庫的插件: // gRPC運行時接口編解碼支持庫 g

moliyiran 2020-07-08 11:15:42

go輸出string類型的字符串

string(out)是string類型。 for循環將其輸出： for i := 0; i < len(string(out)); i++ { fmt.Printf("%c 起始於字位置%d\n", string

Eider1998 2020-07-08 10:54:52

golang image: unknown format 錯誤解決

當使用image.Decode處理圖片文件時，如報image: unknown format 錯誤。 示例 package main import ( "fmt" "image" "os" ) func main()

无风的雨 2020-07-08 10:53:39

`golang` 調用 `etcdv3` 報錯 `undefined: balancer.PickOptions`

錯誤信息： # github.com/coreos/etcd/clientv3/balancer/picker undefined: balancer.PickOptions undefined: balancer.PickOpt

lightserver.cn 2020-07-08 10:10:58

VS Code配置Go語言開發環境

VS Code是微軟開源的一款編輯器，插件系統十分的豐富。本文就介紹瞭如何使用VS Code搭建Go語言開發環境。 VS Code配置Go語言開發環境 說在前面的話，Go語言是採用UTF8編碼的，理論上使用任何文本編輯器都能做Go語言開發

小小土豆爱吃鱼 2020-07-08 09:37:44

GO相同文件夾下相同package不同文件間的函數調用

如：需要在main.go中調用，test1.go中的函數。直接run main.go會報錯如下 調用代碼： test1.go package main import "fmt" func test0007() { fmt.

弘毅密令 2020-07-08 09:18:09

華容道 遊戲

import java.awt.*; import java.awt.event.*; public class MoveExample { public static void main(String args[]) { ne

Crazy的 2020-07-08 07:10:19

在 Go 語言項目中使用 Docker

容器（Container）將程序及其所需的任何內容捆綁在一起，包括依賴項、工具和配置文件等等。這樣使得程序不受環境的干擾，真正意義上做到開發環境和生成環境完全一致。 而 Docker 在容器的基礎上，進行了進一步的封裝，從文件系統

Java小罗 2020-07-08 06:52:09

使用gomail發送郵件

1.相關配置（本文采用toml配置，可根據實際情況自行編寫配置） dev.toml [email] host="smtp.mxhichina.com" port=465 username="[email protected]" password

ula_liu 2020-07-08 06:11:46

go自定義日誌輸出到文件

本文使用go標準庫log進行日誌記錄 1.編寫自定義日誌收集器 package logger import ( "io" "log" "os" ) var ( Info *log.Logger

ula_liu 2020-07-08 06:11:46

go-xorm入門教程

1. 創建Orm引擎 xorm支持同時存在多個orm引擎，一個引擎一般對應一個數據庫，調用xorm.NewEngine(driverName, dataSourceName)方法創建引擎，示例如下： package model

ula_liu 2020-07-08 06:11:46

toml的使用示例

1.編寫配置文件 xx.toml [email] host="smtp.mxhichina.com" port=465 username="[email protected]" password="xxxxx" toUsers = [ "xxxx

ula_liu 2020-07-08 06:11:46