一文详解golang通过io包进行文件读写（golang io.writer）一篇读懂

随心笔谈2年前发布编辑

155 0

🌐 经济型：买域名、轻量云服务器、用途：游戏网站等《腾讯云》特点：特价机便宜适合初学者用点我优惠购买

🚀 拓展型：买域名、轻量云服务器、用途：游戏网站等《阿里云》特点：中档服务器便宜域名备案事多点我优惠购买

🛡️ 稳定型：买域名、轻量云服务器、用途：游戏网站等《西部数码》特点：比上两家略贵但是稳定性超好事也少点我优惠购买

目录1.io包的读写函数2.io.ioutil包实现读写操作

在语言中，实现io的读与写，只要实现了如下的读写接口即可:

// go 1.19/src/io/io.go

type Reader interface {
Read(p []byte) (n int, err error)
}

type Writer interface {
Write(p []byte) (n int, err error)
}

语言自身提供了很多实现这两个接口的结构体，比较典型的有：等，这些解决了文件的读写，字节、字符串的读写，或者是带缓冲的读写等。

今天我们先来看看中提供的这些接口，简单了解下相关原理。

典型的相关函数声明如下：

// 读操作
func ReadAll(r Reader) ([]byte, error) {…}

// 写操作
func Copy(dst Writer, src Reader) (written int64, err error) {…}

func WriteString(w Writer, s string) (n int, err error) {…}

在上面的函数中，接收一个类型的参数，比如类型，又或者是其他的实现了接口的结构体类型，输出读取到的内容，以字节数组形式输出，外附一个错误，我们进一步看看其内部实现：

func ReadAll(r Reader) ([]byte, error) {
// 新建字节数组，cap=512
b :=make([]byte, 0, 512)
// 开启循环读取内容
for {
//
if len(b)==cap(b) {
// Add more capacity (let append pick how much).
b=append(b, 0)[:len(b)]
}
// 读取 reader中的内容，填充到对应部分
n, err :=r.Read(b[len(b):cap(b)])
b=b[:len(b)+n]
// 如果读到了结尾，可以返回数据
if err !=nil {
if err==EOF {
err=nil
}
return b, err
}
}
}

从上面源码可以知道，函数，通过一次读取中的所有内容，如果是小文件无所谓，占用内存有限，但如果是好几个G的文件呢，是不是，本来服务器内存有限，以下占用几G内存，这样读取不太合理，当然，也为我们提供了带缓冲的读取，这是后话，后面再讨论。

接下来看看写入操作的源码实现：

// io.Copy()
func Copy(dst Writer, src Reader) (written int64, err error) {
return copyBuffer(dst, src, nil) // 实际通过调用此函数实现
}

func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
if buf !=nil && len(buf)==0 { // 当buf非空或者长度0，panic
panic(“empty buffer in CopyBuffer”)
}
return copyBuffer(dst, src, buf) // 继续往下调用
}

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 { // 源实现了writeTo就可以直接调用结束
return wt.WriteTo(dst)
}
// Similarly, if the writer has a ReadFrom method, use it to do the copy.
if rt, ok :=dst.(ReaderFrom); ok { // 目标实现了readFrom，也可以直接调用结束
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) // buf空时，创建buf
}
// 开启循环内容读取
for {
nr, er :=src.Read(buf) // 从源中读取内容到buf中
if nr > 0 {
nw, ew :=dst.Write(buf[0:nr]) // 目标w从buf中写入内容
if nw < 0 || nr < nw {
nw=0
if ew==nil {
ew=errInvalidWrite
}
}
written +=int64(nw) // 更新写入长度
if ew !=nil { // 写入返回err，退出循环
err=ew
break
}
if nr !=nw { // 读取与写入长度不等，退出
err=ErrShortWrite
break
}
}
if er !=nil { // 读err非空，退出
if er !=EOF {
err=er
}
break
}
}
return written, err // 返回写入长度及err
}

通过源码走读，我们可以看到，在函数中传入作为目标写入对象，传入作为源读取对象，如果对象实现方法，我们可以直接调用此完成 , 或者是对象实现了方法，我们可以直接调用此完成，都没有实现，就只有通过作为中转，通过循环，先从源读取内容，再写入目标对象中，最后返回整个内容的长度，当然其中也有相关错误处理，这里不做讨论。

接下来中提供的另外的写入操作实现：

// io.WriteString()
func WriteString(w Writer, s string) (n int, err error) {
if sw, ok :=w.(StringWriter); ok { // 如w实现了 StringWriter，则调用相关方法实现写入
return sw.WriteString(s)
}
return w.Write([]byte(s)) // 作为兜底，w对象是肯定实现了 Write() 方法，所以调用此方法实现写入
}

从上面代码可以看到，该实现逻辑简单，具体见注释。

准备：

file.txt，作为读取源，然后再写入其他文件中写操作，我们实现了2种，一种，一种，具体使用见下面代码：

func ioRW() {
// read
f, err :=os.Open(“D:\\demo1\\src\\demo23\\go-io\\file\\file.txt”)
defer f.Close()
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}
b, err :=io.ReadAll(f)
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}
fmt.Printf(“ioRW read content: \n%s\n”, b)

// write
// 1.io.Copy()
fw, err :=os.Create(“io_w.txt”)
defer fw.Close()
n, err :=io.Copy(fw, strings.NewReader(string(b)))
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}
// 2.io.WriteString()
fw_1, _ :=os.Create(“io_w_1.txt”)
defer fw_1.Close()
n, err :=io.WriteString(fw_1, string(b))
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}

fmt.Printf(“ioRW write size: %d\n”, n)
}

所谓，肯定是作为工具使用，怎么方便怎么来，我们甚至通过文件名就可以完成操作，具体实现细节我们不关心，总之它实现了这些功能。

由于我使用的，在源码中，明确声明在后，逐渐弃用了，所以使用高版本的时要注意这个问题，这里为了增加源码的了解熟悉，也拿出来作为分享。

// Deprecated: As of Go 1.16, this function simply calls io.ReadAll.
func ReadAll(r io.Reader) ([]byte, error) {
return io.ReadAll(r)
}

// Deprecated: As of Go 1.16, this function simply calls os.ReadFile.
func ReadFile(filename string) ([]byte, error) {
return os.ReadFile(filename)
}

在中，实际也是调用上面的，这里不赘述，在中，我们传入个文件名，就可以读取到整个字节内容，实际它也是调用实现，后面再讨论。

// Deprecated: As of Go 1.16, this function simply calls os.WriteFile.
func WriteFile(filename string, data []byte, perm fs.FileMode) error {
return os.WriteFile(filename, data, perm)
}

可以看到，这里也是调用了实现文件的写入，只需要我们传入待写入的文件名，写入的字节数组，以及写入文件的权限，是不是很简单。

func ioutilRW() {
// read
b, err :=ioutil.ReadFile(“D:\\demo1\\src\\demo23\\go-io\\file\\file.txt”)
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}

fmt.Printf(“ioutilRW read content: \n%s\n”, b)

// write
err=ioutil.WriteFile(“ioutilRW_w.txt”, b, 664)
if err !=nil {
fmt.Printf(“err: %s\n”, err)
return
}
fmt.Println(“ioutilRW write err: “, err)
}

上面的读取与写入操作实际很简单，代码操作没难度，相信你一看就懂。

今天我们通过接口了解了实现了该接口的都可以作为相关对象，通过也实现了文件的读写，后面我们会陆续分享基于的读写操作，毕竟范围还是很广，只是一部分。

到此这篇关于一文详解golang通过io包进行文件读写的文章就介绍到这了,更多相关golang通过io包文件读写内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:golang bufio包中Write方法的深入讲解详解golang中bufio包的实现原理Golang+Android基于HttpURLConnection实现的文件上传功能示例GOLang?IO接口与工具使用方法讲解解决golang编译提示dial tcp 172.217.160.113:443: connectex: A connection attempt failed(推荐)深入解析golang?bufioGolang中的time.Duration类型用法说明