Go 文件的讀取操作

os 包 和 bufio 包

Go 標(biāo)準(zhǔn)庫的 os 包，為我們提供很多操作文件的函數(shù)，如 Open(name) 打開文件、Create(name) 創(chuàng)建文件等函數(shù)，與之對應(yīng)的是 bufio 包，os 包是直接對磁盤進行操作的，而 bufio 包則是帶有緩沖的操作，不用每次都去操作磁盤。

os.Open 與 os.OpenFile 以及 File.Read

• Open(name string) (*File, error)

  通過 文件名 或 文件路徑+文件名 的形式打開一個文件，此文件只能用于讀操作，如果文件不存在則返回 PathError 。

  • 參數(shù) name 為文件名或文件路徑+文件名。
  • 返回值 *File 為一個 File 結(jié)構(gòu)體的指針類型，通過指針可以對文件進行讀寫等操作。

返回值

`error` 為打開文件的過程中產(chǎn)生的錯誤。

OpenFile(name string, flag int, perm FileMode) (*File, error)

通過指定 文件名 或 文件路徑+文件名、文件操作模式、文件權(quán)限三個參數(shù)打開一個文件，之后可對此文件進行讀寫操作。

• 參數(shù) name 為文件名或文件路徑+文件名。
• 參數(shù) flag 為指定文件操作模式，可選值有 O_RDONLY → 只讀操作、O_WRONLY → 只寫操作、O_RDWR → 讀寫操作、O_APPEND → 寫入時向文件追加數(shù)據(jù)、O_CREATE → 如果不存在，則創(chuàng)建一個新文件等。
• 參數(shù) perm 參數(shù)表示文件的模式和權(quán)限，例如 0666 為讀寫權(quán)限。如果對文件權(quán)限所對應(yīng)的數(shù)字不了解，可以去學(xué)習(xí)一下。
• 返回值 *File 為一個 File 結(jié)構(gòu)體的指針類型，通過指針可以對文件進行讀寫等操作。
• 返回值 error 為打開文件的過程中產(chǎn)生的錯誤。

File.Read(b []byte) (n int, err error)

讀取與 b 等長度的字節(jié)，并存儲到 b 里面。

• 參數(shù) b 為一個切片數(shù)組，用于指定讀取長度和存儲字節(jié)數(shù)據(jù)。
• 返回值 n 為所讀取字節(jié)的長度。
• 返回值 error 為讀取字節(jié)的過程中產(chǎn)生的錯誤。

讀取文件操作

import (
    "fmt"
    "os"
)
func main() {
    file, err := os.Open("1.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()
    data := make([]byte, 11)
    count, err := file.Read(data)
    if err != nil {
        return
    }
    fmt.Println("字節(jié)數(shù)據(jù)：", data)          // [72 101 108 108 111 32 119 111 114 108 100]
    fmt.Println("字符串?dāng)?shù)據(jù)：", string(data)) // Hello world
    fmt.Println("所獲取字節(jié)的長度：", count)     // 11
}

執(zhí)行結(jié)果：

字節(jié)數(shù)據(jù)： [72 101 108 108 111 32 119 111 114 108 100]
字符串?dāng)?shù)據(jù)： Hello world
所獲取字節(jié)的長度： 11

• 首先通過 Open 函數(shù)打開 1.txt 文件，用 file 變量接收，默認(rèn)為可讀模式；
• 然后創(chuàng)建一個長度為 11 的字節(jié)切片，接著通過 file 變量的方法 Read 讀取長度為 11 的字節(jié)數(shù)據(jù)。os.Open("1.txt") 等價于 os.OpenFile("1.txt", os.O_RDONLY, 0)。
• 最后打印讀取到的數(shù)據(jù)，文件操作完畢之后，需要關(guān)閉文件 file.Close()。

bufio.NewReader 和 Reader.ReadString

讀取文件，建議使用 bufio.NewReader 和 Reader.ReadString，減少磁盤的操作。

• NewReader(rd io.Reader) *Reader獲取一個有緩沖區(qū)的 Reader 指針變量，緩沖區(qū)默認(rèn)大小為 4096 字節(jié)。通過變量可以對數(shù)據(jù)進行讀操作。

  • 參數(shù) rd 為一個接口，實現(xiàn)這個接口的數(shù)據(jù)類型變量都可以作為參數(shù)，例如上面提到的 File。
  • 返回值 *Reader 為 Reader 結(jié)構(gòu)體的指針，通過指針可以讀取緩沖區(qū)的數(shù)據(jù)。

• ReadString(delim byte) (string, error)讀取數(shù)據(jù)，直到第一次遇到分隔符 delim 為止。讀取過程中發(fā)生錯誤會返回 EOF 錯誤信息。

  • 參數(shù) delim 為分隔符，每次讀取時遇到分隔符就會終止。
  • 第一個返回值為所讀取的內(nèi)容，內(nèi)容包括分隔符。
  • 第二個返回值為讀取過程中產(chǎn)生的錯誤信息。

讀取文件操作

1.txt 文件的內(nèi)容為：

Hello world
Hello Golang
Hello Gopher

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    file, err := os.OpenFile("1.txt", os.O_RDONLY, 0)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        if lineData, err := reader.ReadString('\n'); err != nil {
            if err == io.EOF {
                // 因為是以換行符為分隔符，如果最后一行沒有換行符，那么返回 io.EOF 錯誤時，也是可能讀到數(shù)據(jù)的，因此判斷一下是否讀到了數(shù)據(jù)
                if len(lineData) > 0 {
                    fmt.Println(lineData)
                }
                break
            }
        } else {
            fmt.Println(strings.TrimRight(lineData, "\n"))
        }
    }
}

執(zhí)行結(jié)果：

Hello World
Hello Golang
Hello Gopher

• 首先通過 OpenFile 函數(shù)打開 1.txt 文件，用 file 變量接收，指定為可讀模式；
• 然后通過 NewReader 函數(shù)創(chuàng)建一個緩沖區(qū)，將默認(rèn)長度的字節(jié)讀取到緩沖區(qū)中；
• 接著通過 Reader 結(jié)構(gòu)體的方法 ReadString，以 \n 為分隔符，按行讀取數(shù)據(jù)，然后打印數(shù)據(jù)。
• 其中有一個注意點就是，因為是以換行符為分隔符，如果最后一行沒有換行符，那么返回 io.EOF 錯誤時，也是可能讀到數(shù)據(jù)的，因此需要判斷一下是否讀到了數(shù)據(jù)。

Go 文件的寫入操作

File.Write、File.WriteString、File.WriteAt

• File.Write(b []byte) (n int, err error)

  直接操作磁盤往文件里寫入數(shù)據(jù)，寫入單位為字節(jié)。

  • b 參數(shù)：寫入的數(shù)據(jù)，類型為字節(jié)切片。
  • 返回值 n：寫入的字節(jié)數(shù)。
  • 返回值 err：寫入數(shù)據(jù)的過程中產(chǎn)生的錯誤。

• File.WriteString(s string) (n int, err error)

  直接操作磁盤往指定文件里寫入數(shù)據(jù)，寫入單位為字符串。

  • s 參數(shù)：寫入的字符串?dāng)?shù)據(jù)。
  • 返回值 n：寫入的字節(jié)數(shù)。
  • 返回值 err：寫入數(shù)據(jù)的過程中產(chǎn)生的錯誤。

• File.WriteAt(b []byte, off int64) (n int, err error)

  從指定位置 off 往文件里順序?qū)懭霐?shù)據(jù)，如果某個偏移量上有數(shù)據(jù)，則會覆蓋。

  • b 參數(shù)：寫入的數(shù)據(jù)，類型為字節(jié)切片。
  • off 參數(shù)：偏移量，從此位置開始寫入數(shù)據(jù)。
  • 返回值 n：寫入的字節(jié)數(shù)。
  • 返回值 err：寫入數(shù)據(jù)的過程中產(chǎn)生的錯誤。

文件寫入操作

import (
    "fmt"
    "os"
)
func main() {
    file, err := os.OpenFile("test.txt", os.O_CREATE, 0)
    if err != nil {
            fmt.Println(err)
            return
    }
    defer file.Close()
    count, err := file.Write([]byte{'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\n'})
    if err != nil {
            return
    }
    fmt.Printf("寫入了 %d 字節(jié)\n", count)
    count, err = file.WriteString("Hello Golang")
    if err != nil {
            return
    }
    fmt.Printf("寫入了長度為 %d 的字符串\n", count)
    count, err = file.WriteAt([]byte{'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'}, 0)
    if err != nil {
            return
    }
    fmt.Printf("寫入了 %d 字節(jié)\n", count)
}

• 首先打開 test.txt 文件，指定的模式為 os.O_CREATE，如果文件不存在則會自動創(chuàng)建；
• 然后通過 Write 方法以字符的形式往文件里寫入 Hello World\n 的內(nèi)容；

接著通過 WriteString 方法以字符串的形式往文件里寫入 Hello Golang 內(nèi)容；此時文件里的內(nèi)容如下所示：

Hello World
Hello Golang

最后通過 WriteAt 方法，指定從偏移量為 0 的位置開始寫入數(shù)據(jù) xxxxxxxxxxx，由于 0 以及之后位置都有數(shù)據(jù)，因此原有數(shù)據(jù)被覆蓋了。最后文件的內(nèi)容為：

xxxxxxxxxxx
Hello Golang

File.Seek

• File.Seek(offset int64, whence int)

  相對于開頭位置或當(dāng)前位置或末尾位置，將設(shè)置當(dāng)前讀或?qū)懙钠屏吭O(shè)置為 offset。

  • offset 參數(shù)：所要設(shè)置的偏移量。
  • whence：相對于哪個位置開始設(shè)置偏移量的標(biāo)志，可選值為 0 → 開頭位置，1 → 當(dāng)前位置，2 → 末尾位置。

應(yīng)用

import (
    "fmt"
    "os"
)
func main() {
    file, err := os.OpenFile("test.txt", os.O_CREATE, 0)
    if err != nil {
            fmt.Println(err)
            return
    }
    defer file.Close()
    _, err = file.WriteString("G0lang")
    if err != nil {
            return
    }
    _, err = file.Seek(1, 0)
    if err != nil {
            fmt.Println(err)
            return
    }
    _, err = file.Write([]byte{'o'})
    if err != nil {
            fmt.Println(err)
            return
    }
}

• 打開 test.txt 文件，指定的模式為 os.O_CREATE，如果文件不存在則會自動創(chuàng)建；
• 使用 WriteString 方法往文件里寫入 G0lang 字符串；
• 此時發(fā)現(xiàn)第二個字符錯了，0 應(yīng)該改成 o；此時的偏移量是指向尾部的；使用 Seek 方法將偏移量移到第二個位置，然后寫入字符 o，由于當(dāng)前位置已有數(shù)據(jù) 0，因此 o 將會覆蓋 0；

bufio.NewWriter、Writer.WriteString、Writer.Flush

如果需要多次執(zhí)行寫入文件的操作，推薦使用 bufio 里的 Writer 結(jié)構(gòu)體去操作，它會開辟一個緩沖區(qū)，默認(rèn)大小為 4096 字節(jié)。在數(shù)據(jù)沒有被刷入磁盤之前，所寫入的數(shù)據(jù)都會暫時保存到緩沖區(qū)里。

• NewWriter(w io.Writer) *Writer

  開辟一個默認(rèn)值為 4096 字節(jié)的緩沖區(qū)，用于暫存寫入文件的數(shù)據(jù)內(nèi)容，返回一個 Writer 結(jié)構(gòu)體的指針變量

  • w 參數(shù)：類型為 Writer 接口，實現(xiàn)這個接口的數(shù)據(jù)類型變量都可以作為參數(shù)，例如 File。
  • 返回值 *Writer：一個 Writer 結(jié)構(gòu)體的指針變量，通過該變量可以往緩沖區(qū)里寫入數(shù)據(jù)。

• Writer.WriteString(s string) (int, error)

  往緩沖區(qū)寫入內(nèi)容的方法。

  • 參數(shù) s 為寫入的字符串。
  • 第一個返回值為寫入的字節(jié)數(shù)。
  • 第二個返回值為寫入數(shù)據(jù)的過程中產(chǎn)生的錯誤。

• Writer.Flush() error

  將所有的緩存數(shù)據(jù)寫入磁盤。

  • 返回值為數(shù)據(jù)寫入磁盤的過程中產(chǎn)生的錯誤。

文件寫入操作

import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    file, err := os.OpenFile("test.txt", os.O_CREATE, 0)
    if err != nil {
            fmt.Println(err)
            return
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    _, err = writer.WriteString("Hello World\n")
    if err != nil {
            fmt.Println(err)
            return
    }
    _, err = writer.WriteString("Hello Golang\n")
    if err != nil {
            fmt.Println(err)
            return
    }
    _, err = writer.WriteString("Hello Gopher\n")
    if err != nil {
            fmt.Println(err)
            return
    }
    writer.Flush()
}

• 首先打開 test.txt 文件，指定的模式為 os.O_CREATE，如果文件不存在則會自動創(chuàng)建；
• 然后使用 NewWriter 函數(shù)獲取一個 Writer 結(jié)構(gòu)體的指針變量 writer；
• 接著通過 writer 的 WriteString 方法將內(nèi)容保存到緩沖區(qū)里；
• 最后調(diào)用 Flush 方法，將所有的緩存數(shù)據(jù)寫入磁盤。

小結(jié)

文件的讀取操作推薦 bufio 包里的 NewReader 函數(shù)和 Reader 結(jié)構(gòu)體的方法 ReadString，能減少對磁盤的操作，高效讀取數(shù)據(jù)。

文件的寫入操作推薦 bufio.NewWriter、Writer.WriteString、Writer.Flush，使用它們代替 File 結(jié)構(gòu)體里的寫入方法，可以不用頻繁操作磁盤，提高寫入效率。

以上就是Go 文件讀取和寫入操作全面的詳細內(nèi)容，更多關(guān)于Go 文件的讀取和寫入操作的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論