重学Go语言 | Go文件操作

公众号：程序员读书；欢迎关注

有很多场景都需要对文件进行读取或者写入，比如读取配置文件或者写入日志文件，除此之外，有时候我们也需要修改文件名称，遍历目录内的文件，删除文件，在Go语言中，操作文件应该算是一件比较简单的事情，我们在这一篇文章中，一起来探究一下。

文件句柄:os.File

在Go语言中，标准库os包下的File结构体表示一个文件句柄，获得了os.File，就可以对文件进行各种操作，要获得一个os.File文件句柄，有以下三种方式：

os.Create

通过os.Create()函数传入一个文件名称可以创建并获得一个表示该文件的os.File结构体：

file,err := os.Create("./my.dat")

如果指定的文件不存在，调用该函数后，会创建文件，如果文件已经存在，则只会清空文件的内容。

os.Open

对于已经存在的文件，如果不想清空文件内容，只想打开该文件的话，可以用os.Open()函数：

file, err := os.Open("./my.dat")

用该函数打开一个文件句柄时，如果文件不存在，返回值err返回一个error类型的错误。

os.OpenFile

其实，os.Create()函数和os.Open()函数的底层都是调用os.OpenFile()函数，这一点从os.Creat()和os.Open()函数的源码可以得到证实：

//该源码位于标准库os包下的file.go文件中
func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0)
}

func Create(name string) (*File, error) {
	return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}

os.OpenFile()函数签名如下：

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

从函数签名可以看到调用os.OpenFile函数时要传入三个参数，其中name是表示要打开的文件名。

而第二个参数flag表示打开文件的标志，比较常用有以下几种取值：

• O_RDONLY：只读

• O_WRONLY：只写

• O_RDWR：读写

• O_APPEND：以追加的方式写入

• O_CREATE：文件不存在时创建

• O_TRUNC：当文件存在时，将文件内容置空

可以同时指定多个标志，多个标志用逻辑运算符|连接起来，比如os.Create()函数在调用os.OpenFile函数时就传入多个标志：

OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)

os.OpenFile()函数的第三个参数 FileMode就是指类Unix操作系统中的文件读写权限，即r(读)、w(写),x(执行)，一个文件的rwx有三组：

-rw-r--r--   1 root  staff  215  4 17 11:14 main.go

-rw-r--r--分别表示文件拥有者、拥有者所在群组、其他人对该文件的权限,如果没有该权限用-表示。

rwx用八进制表示时r=4，w=2，x=1,所以上面main.go文件权限用八进制表示为0644。

无论是用哪种方式打开的文件句柄，最终都要记得关闭以释放资源，比较标准的用法是用defer语句：

name := "./my.dat"
file,err := OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0755) 
if err != nil{
  panic(err)
}
defer file.Close()

读取文件

要读取文件的内容，在获得文件句柄时，OpenFile函数的参数flag只需要传O_RDONLY就可以了,而参数FileMode可以为0:

file, err := os.OpenFile("./my.dat", os.O_RDONLY, 0)

os.File有一个Read()方法，也就是说os.File实现io.Reader接口，Go标准库很多的包可以处理io.Reader接口，比如ioutil,bufio,fmt等，因此有很多种方式可以读取文件的内容。

直接读取

os.File的Read方法就可以直接将文件内容读取一个字节数组中，并返回读取的长度和一个用于判断是否出错的error类型：

package main

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

func main() {
	f, err := os.Open("./my.dat")
	if err != nil {
		panic(err)
	}
	defer f.Close()
	for {
		b := make([]byte, 10) 
		n, err := f.Read(b) //将文件内容读取到字节数组中
		if n == 0 || err == io.EOF {
			return
		}
		fmt.Println(n, string(b))
	}
}

在上面的例子中，我们循环读取文件内容，直到读取到文件末尾时，返回的字节长度0和一个io.EOF的error类型，这时候表示文件已经读完，可以结束读取了。

使用bufio包读取文件

当要用bufio包读取文件时，将调用bufio.NewReader()函数将io.Reader包装为一个bufio.Reader结构体，该结构体封装了很多更便捷读取文件的方法：

func (b *Reader) Read(p []byte) (n int, err error)
func (b *Reader) ReadByte() (byte, error)
func (b *Reader) ReadBytes(delim byte) ([]byte, error)
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
func (b *Reader) ReadRune() (r rune, size int, err error)
func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
func (b *Reader) ReadString(delim byte) (string, error)

下面是ReadLine方法的使用示例：

package main

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

func main() {
	file, err := os.OpenFile("./my.dat", os.O_RDWR, 0666)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	reader := bufio.NewReader(file)
	for {
    //按行读取
		b, _, err := reader.ReadLine() 
		if err == io.EOF {
			break
		}
		fmt.Println(string(b))
	}
}

使用fmt包读取文件

fmt包以FScan...开头的函数可以按一定的格式扫描读取文件里的内容：

func Fscan(r io.Reader, a ...any) (n int, err error)
func Fscanf(r io.Reader, format string, a ...any) (n int, err error)
func Fscanln(r io.Reader, a ...any) (n int, err error)

下面是Fscanln方法的使用示例：

package main

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

func main() {
	file, err := os.OpenFile("./my.dat", os.O_RDWR, 0666)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	for {
		var a1, a2 string
		_, err := fmt.Fscanln(file, &a1, &a2)
		fmt.Println(a2, a2)
		if err == io.EOF {
			break
		}
	}
}

使用ioutil包读取文件

标准库的ioutil包对读取文件做好封装，可以直接读取整个文件的数据：

f, err := os.Open("./my.dat")
if err != nil {
		panic(err)
}
var b []byte
b,err := ioutil.ReadAll(f)

ioutil甚至封装了直接读取文件的函数：

var b []byte
b,err := ioutil.ReadFile("./my.dat")

写入文件

要向文件写入内容，在调用OpenFile()函数获得句柄时flag参数要传入O_WRONLY或者O_RDWR，如果是要往文件中以追加的形式在文件后面插入内容，还是需要O_APPEND:

OpenFile(name, O_RDWR|O_CREATE|O_APPEND, 0666)

os.File有Write方法，也就是说os.File也实现了io.Writer接口，所以同样可以调用fmt、bufio、ioutil包将数据写入到文件中。

直接写入

写入文件最简单的方式就是调用os.File类型的Write方法写入一个字节数组：

package main

import "os"

func main() {

	file, err := os.OpenFile("./my.dat", os.O_RDWR, 0666)

	if err != nil {
		panic(file)
	}
	defer file.Close()
	file.Write([]byte("test222222"))
}

也可以调用os.File的WriteString直接写入一个字符串：

file.WriteString("test222222")

使用bufio包写入文件

bufio包的NewWriter可以将一个io.Writer包装为bufio.Writer结构体,该结构体主要有以下几个方法可以将数据写入文件：

func (b *Writer) Write(p []byte) (nn int, err error)
func (b *Writer) WriteByte(c byte) error
func (b *Writer) WriteRune(r rune) (size int, err error)
func (b *Writer) WriteString(s string) (int, error)

上面几个方法似乎与io.File自身所拥有的方法差别不大，但bufio包的写入是带有缓冲区的，也就是说当我们写入数据时，不是立刻写入到文件，而是写到内存缓冲区，最后调用Flush方法才将数据写入文件。

package main

import (
	"bufio"
	"os"
)

func main() {

	file, err := os.OpenFile("./my.dat", os.O_RDWR, 0666)

	if err != nil {
		panic(err)
	}
	defer file.Close()
	writer := bufio.NewWriter(file)

	writer.Write([]byte("111111111"))
	writer.Flush()
}

使用fmt包写入文件

fmt包以下三个函数可以将格式化的数据写入到一个io.Writer:

func Fprint(w io.Writer, a ...any) (n int, err error)
func Fprintf(w io.Writer, format string, a ...any) (n int, err error)
func Fprintln(w io.Writer, a ...any) (n int, err error)

下面是使用fmt写入文件的示例：

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile("./my.dat", os.O_RDWR, 0666)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	fmt.Fprintf(file, "%s:%s", "username", "test")
}

使用ioutil包写入文件

同样的，ioutil包也对写入文件做了封装，使用一个函数便可以完成上码代码要完成的事情：

ioutil.WriteFile("./my.dat", []byte("22222"), 0666)

判断是否为目录

要判断文件是否为目录，在获得os.File对象，可以调用该对象的Stat方法，该返回返回一个实现了os.FileInfo接口的对象：

type FileInfo interface {
	Name() string       // base name of the file
	Size() int64        // length in bytes for regular files; system-dependent for others
	Mode() FileMode     // file mode bits
	ModTime() time.Time // modification time
	IsDir() bool        // abbreviation for Mode().IsDir()
	Sys() any           // underlying data source (can return nil)
}

示例：

fileInfo, err := file.Stat()

if fileInfo.IsDir() {
	fmt.Println(fileInfo.Name())
}

遍历目录

如果想遍历目录，可以调用os.ReadDir()函数，该函数返回一个元素类型为os.DirEntry的切片:

func (f *File) ReadDir(n int) ([]DirEntry, error)

os.DirEntry是一个接口，其定义如下：

type DirEntry interface {
	Name() string
	IsDir() bool
	Type() FileMode
	Info() (FileInfo, error)
}

可以看到DirEntry接口也有IsDir()方法，因为可以再往下遍历，下面是一个实现目录遍历的示例：

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	base := "./"
	IterateFolder(base)
}

func IterateFolder(base string) {
	dirEntry, err := os.ReadDir(base)
	if err != nil {
		log.Fatal(err)
	}
	for _, v := range dirEntry {
		if v.IsDir() {
			IterateFolder(base   "/"   v.Name())
		} else {
			fmt.Println(v.Name())
		}
	}
}

修改文件名称

修改文件名称用os.Rename函数：

err := os.Rename("./1.txt", "./2.txt")

os.Rename函数也可以用于移动文件：

err := os.Rename("./1.txt", "./m/2.txt")

删除文件

删除一个文件或者一个空目录，直接调用os包的Remove()函数即可：

fileName := "./1.txt"
os.Remove(fileName)

可以根据error的返回值是否为nil判断是否删除成功，比如我们删除一个不存在的文件或者删除一个非空的目录：

//m为当前目录下一个非空目录
err := os.Remove("./m")
fmt.Println(err)

执行结果：

remove ./m: directory not empty

对于非空目录，如果要删除，可以用os包的RemoveAll函数：

err := os.RemoveAll("./m")

小结

好了，至此，相信你对于在Go语言如何读取和写入文件应该掌握了吧，总结一下，在这篇文章中，主要讲了以下几点：

• 如何获得一个文件句柄os.File。
• 如何以不同的方式读取文件内容。
• 如何以不同的方式向文件写入内容。
• 对文件的不同操作。

这篇好文章是转载于：学新通技术网