Go 操作文件

Go 内置库中 io.Reader/Writer 是比较常用的接口。很多原生的接口都围绕这个系列的接口展开，在实际的开发过程中，你会发现通过这个接口可以在多种不同的 io 类型之间进行过渡和转化。

围绕 io.Reader/Writer，Go 语言中有几个常用的实现：

net.Conn, os.Stdin, os.File: 网络、标准输入输出、文件的流读取
strings.Reader: 把字符串抽象成 Reader
bytes.Reader: 把 []byte 抽象成 Reader
bytes.Buffer: 把 []byte 抽象成 Reader 和 Writer
bufio.Reader/Writer: 抽象成带缓冲的流读取（比如按行读写）

可以看到 os.File 结构也实现了 Reader 和 Writer 接口。Go 语言内置的文件读写函数有很多都是基于 Reader 和 Writer 接口实现的。

Go语言中文件读写主要涉及到4个包：

os
io
ioutil
bufio

os 和 io 包读写文件和目录

Go语言最基础的打开文件函数 os.OpenFile

// 返回File指针，打开的文件将会拥有O_RDWR权限（读写权限），
// 传入的os.O_CREATE的意思是，如果文件不存在，则创建该文件，
// 如果创建了文件，则该文件的权限设置为 0766
file2, error := os.OpenFile("./2.txt", os.O_RDWR|os.O_CREATE, 0766)  
if error != nil {
  fmt.Println(error);
}
fmt.Println(file2);
file2.Close();

我们来看一下 OpenFile 的函数定义：

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

第一个参数name表示需要打开的文件路径。

第二个参数flag取值如下，可以组合起来用或运算符，表示要以什么权限打开文件。

const (
    // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
    O_RDONLY int = syscall.O_RDONLY // open the file read-only.
    O_WRONLY int = syscall.O_WRONLY // open the file write-only.
    O_RDWR   int = syscall.O_RDWR   // open the file read-write.

    // The remaining values may be or'ed in to control behavior.
    O_APPEND int = syscall.O_APPEND // append data to the file when writing.
    O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
    O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
    O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
    O_TRUNC  int = syscall.O_TRUNC  // if possible, truncate file when opened.
)

第三个参数 FileMode 为类 Unix 系统文件组权限值，可以直接设置，比如 0755，则表示 “-rwxr-xr-x” 的文件权限。这个参数表示如果创建了文件，则把该文件权限设置成0755。

Go 语言官方建议：绝大多数情况下应该使用 Open 和 Create 方法来打开文件和创建文件，因为它们更简洁更直接。 Open和 Create 方法内部其实也是调用了 OpenFile 来实现的。

打开文件 os.Open(string)

// Open 内部调用 OpenFile，返回 File 指针，打开的文件将会拥有 O_RDONLY 权限
file, error := os.Open("./1.txt")  
if error != nil {
  fmt.Println(error)
}
fmt.Println(file)
file.Close()

来看一下 Go 语言的 Open 源码：

func Open(name string) (*File, error) {
  // 表明Open返回的文件指针对该文件具有O_RDONLY的权限（只读权限）
  return OpenFile(name, O_RDONLY, 0)  
}

创建文件os.Create(string)

file3, error := os.Create("./3.txt");
if error != nil {
  fmt.Println(error);
}
fmt.Println(file3);
file3.Close();

来看一下 Go 语言的 Create 源码：

func Create(name string) (*File, error) {
  // 表明Create返回的文件指针对该文件具有 
  // O_RDWR、O_CREATE 和 O_TRUNC 的权限（读写、创建、删除权限），
  // 该文件的权限设置为 0666
  return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)  
}

读取文件 File.Read([]byte)

file, err := os.Open(`D:\test.py`)
if err != nil {
  fmt.Println(err)
}
// 创建字节切片用于接收文件读取数据（类似于Java中读取文件时的缓冲数组）
buf := make([]byte, 1024)
for {
  length, _ := file.Read(buf)  // Read函数从当前偏移量读取字节切片长度的文件内容到字节切片内。该函数读取完成后，会改变文件当前偏移量
  //读取字节数为0时跳出循环
  if length == 0 {
    break
  }
  fmt.Println(string(buf))
  buf = make([]byte, 1024)
}
file.Close()

偏移量读取文件 File.ReadAt([]byte, int64)

file5, error := os.Open(`D:\address.txt`)
if error != nil {
  fmt.Println(error)
}
//创建字节切片用于接收文件读取数据（类似于Java中读取文件时的缓冲数组）
buf2 := make([]byte, 1024)
ix := 0
for {
  //ReadAt 函数从指定的偏移量开始读取字节切片长度的文件内容到字节切片内。
  len, _ := file5.ReadAt(buf2, int64(ix))  
  ix = ix + len
  if len == 0 {
    break
  }
  fmt.Println(string(buf2))
  buf2 = make([]byte, 1024)
}
file5.Close()

写入文件 File.Write([]byte)、File.WriteString(string)

file6, err := os.Create("./4.txt")
if err != nil {
  fmt.Println(err)
}
data := "我是数据\r\n"
for i := 0; i < 10; i++ {
  // 写入byte的slice数据
  length, _:= file6.Write([]byte(data))
  fmt.Println(length)
  // 写入字符串
  length,_ = file6.WriteString(data)
  fmt.Println(length)
}
file6.Close()

偏移量写入文件 File.WriteAt([]byte, int64)

file7, err := os.Create("./5.txt")
if err != nil {
  fmt.Println(err)
}
for i := 0; i < 10; i++ {
  //按指定偏移量写入数据
  ix := i * 64
  length, _ := file7.WriteAt([]byte("我是数据"+strconv.Itoa(i)+"\r\n"), int64(ix))  //WriteAt函数从指定的偏移量开始写入字节切片长度的文件内容到文件内。
  fmt.Println(length)
}
file7.Close()

删除文件 os.Remove(string)

err := os.Remove("./1.txt")
if err != nil {
  fmt.Println(err)
}

删除路径下所有的文件夹、文件和子文件夹

err := os.RemoveAll("./dir")
if err != nil {
  fmt.Println(err)
}

os 其他有用的文件操作和目录操作

func Chdir(dir string) error
func Exit(code int)
func Getenv(key string) string
func Getwd() (dir string, err error)
func Hostname() (name string, err error)
func IsExist(err error) bool
func IsNotExist(err error) bool
func IsPathSeparator(c uint8) bool
func IsPermission(err error) bool
func Link(oldname, newname string) error
func LookupEnv(key string) (string, bool)
func Mkdir(name string, perm FileMode) error
func MkdirAll(path string, perm FileMode) error
func Readlink(name string) (string, error)
func Remove(name string) error
func RemoveAll(path string) error
func Rename(oldpath, newpath string) error
func SameFile(fi1, fi2 FileInfo) bool
func Setenv(key, value string) error
func Symlink(oldname, newname string) error
func TempDir() string
func Unsetenv(key string) error

ioutil包读写文件和目录

ioutil下只有这么几个非常有用的函数：

func ReadAll(r io.Reader) ([]byte, error)
func ReadFile(filename string) ([]byte, error)
func WriteFile(filename string, data []byte, perm os.FileMode) error
func ReadDir(dirname string) ([]os.FileInfo, error)
func TempFile(dir, pattern string) (f *os.File, err error)
func TempDir(dir, pattern string) (name string, err error)

func ReadAll(r io.Reader) ([]byte, error)

一次性读取 Reader 中的所有内容，返回读取内容的字节切片。如果 error 为 nil 则表示读取成功。其内部使用了 bytes.Buffer 从 io.Reader 中读取所有内容。

// 打开文件，返回文件实例File指针。Go语言中File实现了Reader和Writer接口
file, err := os.Open(`D:\address.txt`)  
if err != nil {
  fmt.Println(err)
}
data, err := ioutil.ReadAll(file)
if err != nil {
  fmt.Println(err)
} else {
  fmt.Println(string(data))
}

func ReadFile(filename string) ([]byte, error)

一次性从参数文件路径表示的文件中读取文件的所有内容，返回读取内容的字节切片。如果 error 为 nil 则表示读取成功。其内部使用了 bytes.Buffer 从 os.Open() 返回的 Reader 中读取所有内容。

data, err := ioutil.ReadFile(`D:\address.txt`)
if err != nil {
  fmt.Println(err)
} else {
  fmt.Println(string(data))
}

func WriteFile(filename string, data []byte, perm os.FileMode) error

一次性把字节切片 data 内容写入到 filename 表示的文件里面。其内部使用了 os.OpenFile() 打开文件和 File.Write() 写入文件内容。

content := "准备写入的内容"
err := ioutil.WriteFile(`D:\address1.txt`, []byte(content), 0666)
if err != nil {
  panic(err)
}

来看一下源码：

func WriteFile(filename string, data []byte, perm os.FileMode) error {
  // 以只写权限O_WRONLY打开文件，如果文件不存在则会创建文件，
  // 如果文件存在，则打开文件的时候会先清空文件内容（O_TRUNC）
  f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
  if err != nil {
    return err
  }
  _, err = f.Write(data)
  if err1 := f.Close(); err == nil {
    err = err1
  }
  return err
}

func ReadDir(dirname string) ([]os.FileInfo, error)

读取目录下的所有文件和目录，返回 FileInfo 切片（os.File结构体实现了FileInfo接口）。

fileInfos, err := ioutil.ReadDir(`D:\`)
if err != nil {
  fmt.Println(err)
}
for index, fileInfo := range fileInfos {
  fmt.Println(index, fileInfo.Name())  // 隐藏文件$RECYCLE.BIN也包含在里面
}

ReadDir 内部使用了 File.Readdir 来读取目录下的所有文件和子目录，还会对结果进行排序。来看一下源码：

// ReadDir reads the directory named by dirname and returns
// a list of directory entries sorted by filename.
func ReadDir(dirname string) ([]os.FileInfo, error) {
  f, err := os.Open(dirname)
  if err != nil {
    return nil, err
  }
  list, err := f.Readdir(-1)
  f.Close()
  if err != nil {
    return nil, err
  }
  sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
  return list, nil
}

TempFile

func TempFile(dir, pattern string) (f *os.File, err error)

在参数 dir 目录下生成一个 pattern 名称的文件，返回生成的文件 File 实例。文件名称将会以 pattern 开头，一串随机数字结尾。如果 pattern 中包含星号 *，则那串随机数字会放在星号的位置，而不是放在结尾。

file, err := ioutil.TempFile(`D:\`, "temp*File")
if err != nil {
  fmt.Println(err)
}
fmt.Println(file.Name())  // 输出：D:\temp584004487File

此时，D盘目录下生成了temp584004487File文件：

func TempDir(dir, pattern string) (name string, err error)

在参数 dir 目录下生成一个 pattern 名称的目录，返回生成的目录路径（含路径和目录名称）。目录名称将会以 pattern 开头，一串随机数字结尾。如果 pattern 中包含星号 *，则那串随机数字会放在星号的位置，而不是放在结尾。

name, err := ioutil.TempDir(`D:\`, "temp*Dir")
if err != nil {
  fmt.Println(err)
}
fmt.Println(name)  // 输出：D:\temp731435683Dir

bufio包读写文件

bufio.NewReader

使用 bufio.NewReader(rd io.Reader) *Reader 创建一个带缓冲区（缓冲区默认大小4096字节）的 Reader 实例，然后使用该 Reader 读文件内容：

f, err := os.Open("connect.go")
defer f.Close()
if err != nil {
  panic(err)
}
//func NewReader(rd io.Reader) *Reader
reader := bufio.NewReader(f)
totLine := 0
for {
  //func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
  content, isPrefix, err := reader.ReadLine()
  fmt.Println(string(content), isPrefix, err)
  // 当单行的内容超过缓冲区时，isPrefix会被置为true；否则为false；
  if !isPrefix {
    totLine++
  }
  if err == io.EOF {
    fmt.Println("一共有", totLine, "行内容")
    break
  }
}

除了 ReadLine 方法，bufio.Reader 还有 ReadString(delim byte) (string, error) 方法，这个 ReadString 方法从 Reader 中读取字符串，直到读到参数 delim，就返回 delim 和之前的字符串。如果将 delim 设置为 \n，相当于按行来读取了。

bufio.NewWriter

使用 bufio.NewWriter(rd io.Writer)*Writer 创建一个带缓冲区（缓冲区默认大小4096字节）的 Writer 实例，然后使用该 Writer 写文件内容：

path := "test.txt"
f, err := os.Create(path)
defer f.Close()
if err != nil {
  panic(err)
}
//func NewWriter(w io.Writer) *Writer
bufferWrite := bufio.NewWriter(f)
if err != nil {
  panic(err)
}
demo := "1234567890"
for _, v := range demo {
  // 将数据写入缓冲区
// func (b*Writer) WriteString(s string) (int, error)
  bufferWrite.WriteString(string(v))
}
data, _:= ioutil.ReadFile(path)
fmt.Println(string(data))   // 输出空的内容
// 将缓冲区的数据写入文件
// func (b *Writer) Flush() error
bufferWrite.Flush()
data,_ = ioutil.ReadFile(path)
fmt.Println(string(data))   // 输出：1234567890

参考：

Go语言进阶之路（七）文件读写os、io、bufio、ioutil

EOF

Power by TeXt.

上篇Linux 使用 126 邮箱发邮件

下篇如何避免 Go 命令行执行产生“孤儿”进程？