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

最新推荐文章于 2023-08-27 09:07:51 发布

程序猿架构

最新推荐文章于 2023-08-27 09:07:51 发布

阅读量3.6k

点赞数 2

分类专栏： Go 文章标签： go

本文链接：https://blog.csdn.net/c315838651/article/details/105614371

版权

Go 专栏收录该内容

10 篇文章 3 订阅

订阅专栏

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
bufio
ioutil

os和io包读写文件和目录

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

file2, error := os.OpenFile("./2.txt", os.O_RDWR|os.O_CREATE, 0766)  // 返回File指针，打开的文件将会拥有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：

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

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

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

创建文件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) {
  return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)  // 表明Create返回的文件指针对该文件具有O_RDWR、O_CREATE和O_TRUNC的权限（读写、创建、删除权限），该文件的权限设置为0666
}

打开文件os.Open(string)和读取文件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 {
  len, _ := file5.ReadAt(buf2, int64(ix))  //ReadAt函数从指定的偏移量开始读取字节切片长度的文件内容到字节切片内。
  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, err := os.Open(`D:\address.txt`)  // 打开文件，返回文件实例File指针。Go语言中File实现了Reader和Writer接口
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
}

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

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

bufio包读写文件

bufio.NewReader(rd io.Reader) *Reader

使用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(rd io.Writer) *Writer

使用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

喜欢的可以关注我的WeiXin订阅号，随时随地学习：

程序猿架构

关注

2
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Go语言进阶之路（七）文件读写os、io、bufio、ioutil

Go内置库中io.Reader/Writer是比较常用的接口。很多原生的接口都围绕这个系列的接口展开，在实际的开发过程中，你会发现通过这个接口可以在多种不同的io类型之间进行过渡和转化。围绕io.Reader/Writer，Go语言中有几个常用的实现： net.Conn, os.Stdin, os.File: 网络、标准输入输出、文件的流读取 strings.Reader:...
复制链接

扫一扫