Go语言文件写入
Posted Go程序员开发
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言文件写入相关的知识，希望对你有一定的参考价值。
Go语言文件写入
文件写入
文件写入常用函数和方法：
func Open(name string) (file *File, err error)
Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。
打开标记：
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_CREATE配合使用，文件必须不存在
O_SYNC int = syscall.O_SYNC // 打开文件用于同步I/O
O_TRUNC int = syscall.O_TRUNC // 如果可能，打开时清空文件
)
文件权限（unix权限位）：只有在创建文件时才需要，不需要创建文件可以设置为 0。os库虽然提供常量，但是我一般直接写数字，如0664。
如果你需要设置多个打开标记和unix权限位，需要使用位操作符"|"
func (f *File) Write(b []byte) (n int, err error)
Write向文件中写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) WriteAt(b []byte, off int64) (n int, err error)
WriteAt在指定的位置（相对于文件开始位置）写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) WriteString(s string) (ret int, err error)
WriteString类似Write，但接受一个字符串参数。
代码实现：
package main
import (
"fmt"
"os"
)
func main() {
file1, err := os.Open("./file1.txt")
if err != nil {
fmt.Printf("open file1.txt err : %v\n", err)
}
if file1 != nil {
defer func(file *os.File) { file.Close() }(file1)
}
file2, err := os.OpenFile("./file2.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
fmt.Printf("openfile file2 err : %v\n", err)
}
if file2 != nil {
defer func(file *os.File) { file.Close() }(file2)
}
b1 := []byte("hello world ! hi write test !\n")
off, err := file2.Write(b1)
if err != nil {
fmt.Printf("file2 write err : %v\n", err)
}
fmt.Printf("file2 write success , off is %v\n", off)
b2 := []byte("hello golang ! hi writeat test !\n")
off, err = file2.WriteAt(b2, int64(off))
if err != nil {
fmt.Printf("file2 writeat err : %v\n", err)
}
fmt.Printf("file2 writeat success , off is %v\n", off)
str := "this is write string test .\n"
off, err = file2.WriteString(str)
if err != nil {
fmt.Printf("file2 write string err : %v\n", err)
}
fmt.Printf("file2 write string success , off is %v\n", off)
}
运行结果：
file2 write success , off is 30
file2 writeat success , off is 33
file2 write string success , off is 28
cat file2.txt
hello world ! hi write test !
hello golang ! hi writeat test !
this is write string test .
缓冲写入
bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。
缓冲写入常用函数和方法：
func NewWriter(w io.Writer) *Writer
NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
func NewWriterSize(w io.Writer, size int) *Writer
NewWriterSize创建一个具有最少有size尺寸的缓冲、写入w的Writer。如果参数w已经是一个具有足够大缓冲的Writer类型值，会返回w。
func (b *Writer) Reset(w io.Writer)
Reset丢弃缓冲中的数据，清除任何错误，将b重设为将其输出写入w。
func (b *Writer) Write(p []byte) (nn int, err error)
Write将p的内容写入缓冲。返回写入的字节数。如果返回值nn < len(p)，还会返回一个错误说明原因。
func (b *Writer) WriteString(s string) (int, error)
WriteString写入一个字符串。返回写入的字节数。如果返回值nn < len(s)，还会返回一个错误说明原因。
func (b *Writer) WriteByte(c byte) error
WriteByte写入单个字节。
func (b *Writer) WriteRune(r rune) (size int, err error)
WriteRune写入一个unicode码值（的utf-8编码），返回写入的字节数和可能的错误。
func (b *Writer) Buffered() int
Buffered返回缓冲中已使用的字节数。
func (b *Writer) Available() int
Available返回缓冲中还有多少字节未使用。
func (b *Writer) Flush() error
Flush方法将缓冲中的数据写入下层的io.Writer接口。
代码实现：
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
file, err := os.OpenFile("./file.txt", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Printf("open file err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
fmt.Println("open file success")
write1 := bufio.NewWriter(file)
space1 := write1.Available()
fmt.Printf("默认缓冲区有 %d 字节\n", space1)
insertByte, err := write1.Write([]byte("默认大小缓冲写入\n"))
if err != nil {
fmt.Printf("write err : %v\n", err)
}
fmt.Printf("write success , 写入 %d 字节\n", insertByte)
useSpace1 := write1.Buffered()
fmt.Printf("默认缓冲区已经使用 %d 字节\n", useSpace1)
//丢弃缓冲中的数据
write1.Reset(file)
write2 := bufio.NewWriterSize(file, 10000)
insertByte2, err := write2.WriteString("this is write string test.\n")
if err != nil {
fmt.Printf("write string err : %v\n", err)
}
fmt.Printf("write string success , 写入 %d 字节\n", insertByte2)
err = write2.WriteByte('a')
if err != nil {
fmt.Printf("write byte err : %v\n", err)
}
insertByte3, err := write2.WriteRune('哈')
if err != nil {
fmt.Printf("write rune err : %v\n", err)
}
fmt.Printf("write rune success , 写入 %d 字节\n", insertByte3)
err = write2.Flush()
if err != nil {
fmt.Printf("write2 flush err : %v\n", err)
}
fmt.Println("write2 flush success")
}
运行结果：
open file success
默认缓冲区有 4096 字节
write success , 写入 25 字节
默认缓冲区已经使用 25 字节
write string success , 写入 27 字节
write rune success , 写入 3 字节
write2 flush success
cat file.txt
this is write string test.
a哈
指定文件写入
使用 io/ioutil 包向指定的文件中写入数据
指定文件写入常用函数：
func WriteFile(filename string, data []byte, perm os.FileMode) error
函数向filename指定的文件中写入数据。如果文件不存在将按给出的权限创建文件，否则在写入数据之前清空文件。
os.FileMode 代表文件的模式和权限位。
这些字位在所有的操作系统都有相同的含义，因此文件的信息可以在不同的操作系统之间安全的移植。
不是所有的位都能用于所有的系统，唯一共有的是用于表示目录的ModeDir位。
const (
// 单字符是被String方法用于格式化的属性缩写。
ModeDir FileMode = 1 << (32 - 1 - iota) // d: 目录
ModeAppend // a: 只能写入，且只能写入到末尾
ModeExclusive // l: 用于执行
ModeTemporary // T: 临时文件（非备份文件）
ModeSymlink // L: 符号链接（不是快捷方式文件）
ModeDevice // D: 设备
ModeNamedPipe // p: 命名管道（FIFO）
ModeSocket // S: Unix域socket
ModeSetuid // u: 表示文件具有其创建者用户id权限
ModeSetgid // g: 表示文件具有其创建者组id的权限
ModeCharDevice // c: 字符设备，需已设置ModeDevice
ModeSticky // t: 只有root/创建者能删除/移动文件
// 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
)
这些被定义的位是FileMode最重要的位。
另外9个不重要的位为标准Unix rwxrwxrwx权限（任何人都可读、写、运行）。
这些（重要）位的值应被视为公共API的一部分，可能会用于线路协议或硬盘标识：它们不能被修改，但可以添加新的位。
代码实现：
package main
import (
"fmt"
"io/ioutil"
"os"
)
func main() {
str := "this is ioutil.WriteFile() test."
err := ioutil.WriteFile("./ioutilWriteFile.txt", []byte(str), os.ModePerm)
if err != nil {
fmt.Printf("ioutil.WriteFile() write ./ioutilWriteFile.txt err : %v\n", err)
}
fmt.Println("ioutil.WriteFile() write ./ioutilWriteFile.txt success.")
}
下一篇：
Go语言文件读取------敬请期待！
第十一章 并发编程
11.1
11.2
11.3
11.4
第十二章 反射
12.1
12.2
第十三章 数据格式
13.1
13.2
第十四章 终端读取
14.1
14.2
第十五章 文件操作
15.1
自2017年6月起，老男孩IT教育就顺应技术发展潮流开设了Go语言开发课程，以帮助更多有需要的盆友们提升技能，若是想要了解具体课程内容的话，那就点击本文左下方“阅读原文”来咨询吧~
看完本文有收获？那就分享给更多人吧！
以上是关于Go语言文件写入的主要内容，如果未能解决你的问题，请参考以下文章