Golang怎么处理文件读写 Golang文件操作教程

林译川

2026-11-08 • 👁 0人浏览过

golang 处理文件读写的核心在于os包和io包的配合使用。os包负责打开、创建、关闭文件，而io包则实现实际读写操作。通过bufio.reader可高效读取大文件，例如逐行读取以降低内存占用。并发写入时需使用sync.mutex或channel确保线程安全。错误处理需显式检查每个步骤的返回值，并注意io.eof作为正常结束标志。ioutil包提供便捷函数如readfile和writefile简化操作，但不适合超大文件。二进制文件可通过encoding/binary包进行数据转换。创建与删除文件分别使用os.create和os.remove。获取文件信息可通过os.stat获取名称、大小及修改时间等。 Golang处理文件读写的核心在于

os

包和

io

包的配合使用。简单来说，

os

包负责打开、创建、关闭文件，而

io

包则负责实际的读写操作。你可以通过不同的

Reader

和

Writer

接口实现各种读写需求，比如按行读取、按块读取等等。打开文件，读取内容，然后关闭文件，这是最基础的文件操作流程。如何高效读取大文件？处理大文件时，一次性将整个文件加载到内存中显然是不现实的。这时，可以使用

bufio

包提供的缓冲读取器

bufio.Reader

。它允许你以更小的块（例如，按行或指定大小的缓冲区）读取文件，从而显著降低内存占用。立即学习 “ go语言免费学习笔记（深入） ”；

package main

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

func main() {
    file, err := os.Open("large_file.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            // 处理文件结束或错误
            break
        }
        fmt.Print(line)
    }
}

这个例子展示了如何逐行读取大文件。

ReadString('\n')

会读取直到遇到换行符为止的内容，这使得处理文本文件非常方便。如何进行并发文件写入？并发写入文件需要特别小心，以避免数据竞争和文件损坏。一种常见的做法是使用互斥锁

sync.Mutex

来保护对文件的写入操作。

package main

import (
    "fmt"
    "os"
    "sync"
)

var (
    file *os.File
    mutex sync.Mutex
)

func writeToFile(data string) {
    mutex.Lock()
    defer mutex.Unlock()

    _, err := file.WriteString(data + "\n")
    if err != nil {
        fmt.Println("Error writing to file:", err)
    }
}

func main() {
    var err error
    file, err = os.OpenFile("concurrent_file.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            writeToFile(fmt.Sprintf("Data from goroutine %d", i))
        }(i)
    }
    wg.Wait()
}

在这个例子中，

sync.Mutex

确保了同一时刻只有一个goroutine可以写入文件。

os.O_APPEND

标志确保每次写入都追加到文件末尾。虽然这种方法可以避免数据竞争，但会限制并发性能。更高级的做法是使用channel来协调写入操作，或者将写入操作分片，最后合并。如何处理文件读写中的错误？ Golang强制你显式地处理错误。在文件读写中，这通常意味着检查

os.Open

、

file.Read

、

file.Write

和

file.Close

等函数的返回值。

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("non_existent_file.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    buffer := make([]byte, 100)
    _, err = file.Read(buffer)
    if err != nil {
        if err == io.EOF {
            fmt.Println("End of file reached")
        } else {
            fmt.Println("Error reading file:", err)
            return
        }
    }
    fmt.Println("Read:", string(buffer))
}

这个例子展示了如何检查文件打开和读取时的错误。特别要注意的是，读取文件结束时会返回

io.EOF

错误，这是一种正常的结束标志，而不是真正的错误。

defer file.Close()

确保文件在使用完毕后会被关闭，即使发生错误。如何使用

ioutil

包简化文件操作？

ioutil

包提供了一些便捷的函数，可以简化常见的文件操作，例如读取整个文件内容或一次性写入数据。

package main

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

func main() {
    content, err := ioutil.ReadFile("my_file.txt")
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }
    fmt.Println("File content:", string(content))

    err = ioutil.WriteFile("new_file.txt", []byte("Hello, world!"), 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }
}

ioutil.ReadFile

可以一次性读取整个文件内容到内存中，

ioutil.WriteFile

则可以一次性将数据写入文件。虽然方便，但需要注意内存占用，不适合处理超大文件。如何处理二进制文件？处理二进制文件需要使用

io.Reader

和

io.Writer

接口，以及

encoding/binary

包。

encoding/binary

包提供了在二进制数据和Go数据结构之间进行转换的功能。

package main

import (
    "encoding/binary"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("binary_file.dat")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    var data int32
    err = binary.Read(file, binary.LittleEndian, &data)
    if err != nil {
        fmt.Println("Error reading binary data:", err)
        return
    }
    fmt.Println("Data:", data)
}

这个例子展示了如何从二进制文件中读取一个

int32

类型的数据。

binary.Read

函数需要指定字节序（例如，

binary.LittleEndian

或

binary.BigEndian

），以及要读取的数据的类型。如何创建和删除文件？

os

包提供了创建和删除文件的函数。

package main

import (
    "fmt"
    "os"
)

func main() {
    // 创建文件
    file, err := os.Create("new_file.txt")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    file.Close()

    // 删除文件
    err = os.Remove("new_file.txt")
    if err != nil {
        fmt.Println("Error removing file:", err)
        return
    }
}

os.Create

函数会创建一个新文件，如果文件已存在则会覆盖它。

os.Remove

函数会删除指定的文件。注意，删除文件需要有足够的权限。如何获取文件信息？

os.Stat

函数可以获取文件的信息，例如文件大小、修改时间等。

package main

import (
    "fmt"
    "os"
)

func main() {
    fileInfo, err := os.Stat("my_file.txt")
    if err != nil {
        fmt.Println("Error getting file info:", err)
        return
    }

    fmt.Println("File name:", fileInfo.Name())
    fmt.Println("File size:", fileInfo.Size(), "bytes")
    fmt.Println("Last modified:", fileInfo.ModTime())
}

os.Stat

函数返回一个

os.FileInfo

接口，其中包含了文件的各种信息。

相关文章