文件读取

一次性读取

byteData, _ := os.ReadFile("go_study/hello.txt")
fmt.Println(string(byteData))

获取当前go文件的路径

可以通过获取当前go文件的路径，然后用相对于当前go文件的路径去打开文件

// GetCurrentFilePath 获取当前文件路径
func GetCurrentFilePath() string {
  _, file, _, _ := runtime.Caller(1)
  return file
}

分片读

file, _ := os.Open("go_study/hello.txt")
defer file.Close()
for {
  buf := make([]byte, 1)
  _, err := file.Read(buf)
  if err == io.EOF {
    break
  }
  fmt.Printf("%s", buf)
}

带缓冲读

按行读

file, _ := os.Open("go_study/hello.txt")
buf := bufio.NewReader(file)
for {
  line, _, err := buf.ReadLine()
  fmt.Println(string(line))
  if err != nil {
    break
  }
}

指定分割符

file, _ := os.Open("go_study/hello.txt")
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanWords) // 按照单词读
//scanner.Split(bufio.ScanLines) // 按照行读
//scanner.Split(bufio.ScanRunes) // 按照中文字符读
//scanner.Split(bufio.ScanBytes) // 按照字节读读，中文会乱码

for scanner.Scan() {
  fmt.Println(scanner.Text())
}

文件写入

一次性写

err := os.WriteFile("go_study/file1.txt", []byte("这是内容"), os.ModePerm)
fmt.Println(err)

文件的打开方式

常见的一些打开模式

// 如果文件不存在就创建
os.O_CREATE|os.O_WRONLY
// 追加写
os.O_APPEND|os.O_WRONLY
// 可读可写
os.O_RDWR

完整的模式

const (
  O_RDONLY int = syscall.O_RDONLY // 只读
  O_WRONLY int = syscall.O_WRONLY // 只写
  O_RDWR   int = syscall.O_RDWR   // 读写
  
  O_APPEND int = syscall.O_APPEND // 追加
  O_CREATE int = syscall.O_CREAT  // 如果不存在就创建
  O_EXCL   int = syscall.O_EXCL   // 文件必须不存在
  O_SYNC   int = syscall.O_SYNC   // 同步打开
  O_TRUNC  int = syscall.O_TRUNC  // 打开时清空文件
)

文件的权限

主要用于linux系统，在windows下这个参数会被无视，代表文件的模式和权限位，

三个占位符

第一个是文件所有者所拥有的权限

第二个是文件所在组对其拥有的权限

第三个占位符是指其他人对文件拥有的权限

R：读，Read的缩写，八进制值为 4；
W：写，Write的缩写，八进制值为 2；
X：执行，Execute的缩写，八进制值为 1；

0444 表示三者均为只读的权限；
0666 表示三者均为“读写”的权限；
0777 表示三者均为读写执行的权限；
0764 表示所有者有读写执行（7=4+2+1）的权限，组有读写（6=4+2）的权限，其他用户则为只读（4=4）；

文件复制

io.Copy(dst Writer, src Reader) (written int64, err error)

将src文件的内容复制到dst文件

read, _ := os.Open("go_study/file1.txt")
write, _ := os.Create("go_study/file3.txt") // 默认是 可读可写，不存在就创建，清空文件
n, err := io.Copy(write, read)
fmt.Println(n, err)

dir, _ := os.ReadDir("go_study")
for _, entry := range dir {
  info, _ := entry.Info()
  fmt.Println(entry.Name(), info.Size()) // 文件名，文件大小，单位比特
}

文件读写代码示例

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

// 读取文件内容
func readFile(filePath string) (string, error) {
    content, err := os.ReadFile(filePath)
    if err != nil {
        return "", err
    }
    return string(content), nil
}

// 写入文件内容
func writeFile(filePath string, content string) error {
    return os.WriteFile(filePath, []byte(content), 0644)
}

// 创建目录（如果尚不存在）
func createDirIfNotExists(dir string) error {
    if _, err := os.Stat(dir); os.IsNotExist(err) {
        err = os.MkdirAll(dir, 0755)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    // 定义一个目录和文件名
    dir := "data"
    err := createDirIfNotExists(dir)
    if err != nil {
        fmt.Println("创建目录错误:", err)
        return
    }

    fileName := "example.txt"
    filePath := filepath.Join(dir, fileName) // 拼接完整文件路径

    // 写入文件
    newContent := "Hello, World!"
    fmt.Println("写入的文件内容:", newContent)
    err = writeFile(filePath, newContent)
    if err != nil {
        fmt.Println("写入文件错误:", err)
        return
    }
    fmt.Println("文件写入成功")

    // 读取文件
    content, err := readFile(filePath)
    if err != nil {
        fmt.Println("读取文件错误:", err)
        return
    }
    fmt.Println("读取的文件内容:", content)
}

临时文件和目录

在程序运行时，我们经常创建一些运行时用到，程序结束后就不再使用的数据。 临时目录和文件 对于上面的情况很有用，因为它不会随着时间的推移而污染文件系统。

package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    // 创建一个临时目录
    tempDir, err := os.MkdirTemp("", "tempDir-")
    if err != nil {
        fmt.Println("创建临时目录错误:", err)
        return
    }
    fmt.Println("创建的临时目录:", tempDir)

    // 在临时目录中创建一个临时文件
    tempFile, err := os.CreateTemp(tempDir, "tempFile-")
    if err != nil {
        fmt.Println("创建临时文件错误:", err)
        return
    }
    fmt.Println("创建的临时文件:", tempFile.Name())

    // 写入临时文件内容
    _, err = tempFile.Write([]byte("Hello, World!"))
    if err != nil {
        fmt.Println("写入临时文件内容错误:", err)
        return
    }

    // 关闭临时文件
    err = tempFile.Close()
    if err != nil {
        fmt.Println("关闭临时文件错误:", err)
        return
    }

    // 读取临时文件内容
    content, err := os.ReadFile(tempFile.Name())
    if err != nil {
        fmt.Println("读取临时文件内容错误:", err)
        return
    }
    fmt.Println("临时文件内容:", string(content))
    time.Sleep(time.Minute)
    // 使用 defer 确保在函数返回前删除临时目录及其内容
    defer os.RemoveAll(tempDir)

    // 使用 defer 确保在函数返回前删除临时文件
    defer os.Remove(tempFile.Name())
}