Golang文件写入的四种方式

文章目录 1. 简单覆盖式文件写入2. 常规文件写入3. 带有缓冲区的文件写入4. 复制 *** 作的文件写入

Golang 中关于文件写入的方法很多

简单覆盖式文件写入常规文件写入带有缓冲区的文件写入复制 *** 作的文件写入

1. 简单覆盖式文件写入

特点 :

*** 作简单一个函数完成数据写入新内容覆盖旧的内容 *** 作的文件不存在的时候会自动创建

使用Golang的标准包 io/ioutil

函数参数说明 :

filename *** 作的文件名

data 写入的内容

perm 文件不存在时创建文件并赋予的权限,例如 : 0666

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

WriteFile 内部实现

func WriteFile(filename string, data []byte, perm os.FileMode) error {
	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
	if err != nil {
		return err
	}
	n, err := f.Write(data)
	if err == nil && n < len(data) {
		err = io.ErrShortWrite
	}
	if err1 := f.Close(); err == nil {
		err = err1
	}
	return err
}

看得出来 WriteFile 的本质是对 os 包中 File 的封装

2. 常规文件写入

特点 :

文件写入灵活 ,对文件的 *** 作更强

*** 作流程 : 打开文件(或者创建文件) ,写入内容 ,关闭文件

使用Golang标准包 os 的 type File 部分 , 其中常用到的方法和函数如下

// 可读可写模式创建文件
func Create(name string) (file *File, err error)
// 只读模式打文件
func Open(name string) (file *File, err error)
// 通用的文件打开函数(综合和 Create 和 Open的作用)
// OpenFile第二个参数 flag 有如下可选项
//    O_RDONLY  文件以只读模式打开
//	  O_WRONLY  文件以只写模式打开
//	  O_RDWR   文件以读写模式打开
//	  O_APPEND 追加写入
//	  O_CREATE 文件不存在时创建
//	  O_EXCL   和 O_CREATE 配合使用,创建的文件必须不存在
//	  O_SYNC   开启同步 I/O
//	  O_TRUNC  打开时截断常规可写文件
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
// 向文件写入字节数据
func (f *File) Write(b []byte) (n int, err error)
// 向文件写入字符串
func (f *File) WriteString(s string) (ret int, err error)
// 关闭文件
func (f *File) Close() error

示例代码

func generalWrite(param string) {
	f, err := os.OpenFile(w2, os.O_RDONLY|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		log.Println("open file error :", err)
		return
	}
	// 关闭文件
	defer f.Close()
	// 字节方式写入
	_, err = f.Write([]byte("write : " + param))
	if err != nil {
		log.Println(err)
		return
	}
	// 字符串写入
	_, err = f.WriteString("writeString : " + param)
	if err != nil {
		log.Println(err)
		return
	}
}

3. 带有缓冲区的文件写入

特点：

先将数据写入缓存区,再由缓冲区写入文件中根据设置缓存的大小,可以存储更多数据然后一次写入文件

数据写入的速度更快一点

使用Golang标准包 bufio 的 Writer 部分 , 其中常用到的方法和函数如下

// 新建一个Writer 采用默认缓冲大小 4096
func NewWriter(w io.Writer) *Writer
// 新建一个Writer 采用自定义缓冲大小
func NewWriterSize(w io.Writer, size int) *Writer
// 字节写入
func (b *Writer) Write(p []byte) (nn int, err error)
// 字符串写入
func (b *Writer) WriteString(s string) (int, error)
// 单字节写入
func (b *Writer) WriteByte(c byte) error
// 写入一个unicode码值（的utf-8编码）
func (b *Writer) WriteRune(r rune) (size int, err error)
// 将缓冲中的数据写入下层的io.Writer接口
func (b *Writer) Flush() error

示例代码

func bufferWrite(param string) {
	fileHandle, err := os.OpenFile(w3, os.O_RDONLY|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		log.Println("open file error :", err)
		return
	}
	defer fileHandle.Close()
	// NewWriter 默认缓冲区大小是 4096
	// 需要使用自定义缓冲区的writer 使用 NewWriterSize()方法
	buf := bufio.NewWriter(fileHandle)
	// 字节写入
	buf.Write([]byte("buffer Write : " + param))
	// 字符串写入
	buf.WriteString("buffer WriteString : " + param)
	// 将缓冲中的数据写入
	err = buf.Flush()
	if err != nil {
		log.Println("flush error :", err)
	}
}

4. 复制 *** 作的文件写入

特点 :

复制出一份相同内容的数据默认带有缓冲并且可以自己设置缓冲区大小 *** 作相对简单

使用Golang标准包 io 的两个函数如下

// 复制 采用系统默认缓冲区大小
func Copy(dst Writer, src Reader) (written int64, err error){}
// 复制 自定义缓冲区大小
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {}

io 包中的 Copy 和 CopyBuffer 函数的核心都是调用了一个内部函数 copyBuffer , 我们看一下它的源代码

io.go

// copyBuffer is the actual implementation of Copy and CopyBuffer.
// if buf is nil, one is allocated.
func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
	// If the reader has a WriteTo method, use it to do the copy.
	// Avoids an allocation and a copy.
	if wt, ok := src.(WriterTo); ok {
		return wt.WriteTo(dst)
	}
	// Similarly, if the writer has a ReadFrom method, use it to do the copy.
	if rt, ok := dst.(ReaderFrom); ok {
		return rt.ReadFrom(src)
	}
	if buf == nil {
		size := 32 * 1024
		if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
			if l.N < 1 {
				size = 1
			} else {
				size = int(l.N)
			}
		}
		buf = make([]byte, size)
	}
	for {
		nr, er := src.Read(buf)
		if nr > 0 {
			nw, ew := dst.Write(buf[0:nr])
			if nw > 0 {
				written += int64(nw)
			}
			if ew != nil {
				err = ew
				break
			}
			if nr != nw {
				err = ErrShortWrite
				break
			}
		}
		if er != nil {
			if er != EOF {
				err = er
			}
			break
		}
	}
	return written, err
}

使用代码示例

func fileCopy(dst, src string) {
	start := time.Now()
	dstWriter, err := os.Create(dst)
	if err != nil {
		log.Println("create file error :", err)
		return
	}
	srcReader, err := os.Open(src)
	if err != nil {
		log.Println("open file error :", err)
		return
	}
	// Copy()函数其实是调用了
	// io包中私有函数copyBuffer() 默认缓冲区是32K
	// 与Copy()函数功能一致的是CopyBuffer()可以设置缓冲区
	c, err := io.Copy(dstWriter, srcReader)
	if err != nil {
		log.Println("copy file error :", err)
		return
	}
	fmt.Println("copy spend :", time.Now().Sub(start), c)
}

参考资料 :

- [1] Golang文档