Golang 在 Linux 中的文件操作

Go 语言提供了丰富的标准库来进行文件操作，这些操作在 Linux 系统上表现良好。下面我将介绍 Golang 在 Linux 环境中进行文件操作的主要方法和最佳实践。

基本文件操作

1. 打开和关闭文件

package main

import (
    "log"
    "os"
)

func main() {
    // 打开文件（只读模式）
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close() // 确保文件最终被关闭

    // 以读写模式打开文件，如果不存在则创建，权限设置为644
    file, err = os.OpenFile("test.txt", os.O_RDWR|os.O_CREATE, 0644)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
}

2. 读取文件

// 读取整个文件
data, err := os.ReadFile("test.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

// 逐行读取
scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}
if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

// 缓冲读取
reader := bufio.NewReader(file)
for {
    line, err := reader.ReadString('\n')
    if err != nil {
        if err == io.EOF {
            break
        }
        log.Fatal(err)
    }
    fmt.Print(line)
}

3. 写入文件

// 写入整个文件
content := []byte("Hello, Linux!")
err := os.WriteFile("output.txt", content, 0644)
if err != nil {
    log.Fatal(err)
}

// 缓冲写入
writer := bufio.NewWriter(file)
_, err = writer.WriteString("Hello, Linux!\n")
if err != nil {
    log.Fatal(err)
}
writer.Flush() // 确保所有缓冲数据写入底层io.Writer

高级文件操作

1. 文件信息与权限

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

// 修改文件权限
err = os.Chmod("test.txt", 0755)
if err != nil {
    log.Fatal(err)
}

// 修改文件所有者
err = os.Chown("test.txt", os.Getuid(), os.Getgid())
if err != nil {
    log.Fatal(err)
}

2. 目录操作

// 创建目录
err := os.Mkdir("mydir", 0755)
if err != nil {
    log.Fatal(err)
}

// 创建多级目录
err = os.MkdirAll("path/to/dir", 0755)
if err != nil {
    log.Fatal(err)
}

// 读取目录内容
files, err := os.ReadDir(".")
if err != nil {
    log.Fatal(err)
}

for _, file := range files {
    fmt.Println(file.Name())
}

// 删除目录
err = os.Remove("mydir")
if err != nil {
    log.Fatal(err)
}

// 递归删除目录
err = os.RemoveAll("path/to/dir")
if err != nil {
    log.Fatal(err)
}

3. 文件移动和重命名

// 重命名文件
err := os.Rename("oldname.txt", "newname.txt")
if err != nil {
    log.Fatal(err)
}

// 移动文件（在同一文件系统中）
err = os.Rename("/tmp/file.txt", "/home/user/file.txt")
if err != nil {
    log.Fatal(err)
}

4. 符号链接操作

// 创建符号链接
err := os.Symlink("original.txt", "link.txt")
if err != nil {
    log.Fatal(err)
}

// 读取符号链接目标
target, err := os.Readlink("link.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println("Link target:", target)

文件锁定

在 Linux 中，Go 可以使用 syscall 包实现文件锁定：

import "syscall"

func lockFile(f *os.File) error {
    err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        return fmt.Errorf("failed to lock file: %v", err)
    }
    return nil
}

func unlockFile(f *os.File) error {
    err := syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
    if err != nil {
        return fmt.Errorf("failed to unlock file: %v", err)
    }
    return nil
}

最佳实践

1. 始终检查错误：Go 的文件操作函数通常返回错误，必须检查这些错误。

2. 使用 defer 关闭文件：这样可以确保文件描述符不会泄漏。

3. 考虑使用缓冲 I/O：对于大量小数据读写，使用 bufio 可以提高性能。

4. 处理大文件时注意内存：对于大文件，避免使用 ReadFile 一次性读取整个文件。

5. 注意文件权限：特别是在创建新文件时，设置适当的权限 (如 0644 或 0755)。

6. 跨平台考虑：虽然这些操作在 Linux 上工作，但要注意路径分隔符 (/ vs \) 等跨平台问题。

7. 考虑使用 ioutil.TempFile 创建临时文件，它会自动处理文件名冲突。

通过掌握这些文件操作技术，你可以在 Linux 环境下高效地使用 Golang 处理各种文件相关的任务。