Go语言编程中对文件读写的基本方法整理
1.func copy(dst writer, src reader) (written int64, err error)这个函数是从一个文件读取拷贝到另外一个文件,一直拷贝到读取文件的eof,所以不会返回io.eof错误,参数是写入目标器和读取目标器,返回int64的拷贝字节数和err信息
import (
"fmt"
"io"
"os"
)
func main() {
r, _ := os.open("test.txt")
w, _ := os.create("write.txt")
num, err := io.copy(w, w)
if err != nil {
fmt.println(err)
}
fmt.println(num) //返回int64的11 打开我的write.txt正是test.txt里边的hello widuu
}
2.func copyn(dst writer, src reader, n int64) (written int64, err error)看函数就知道了跟上述的是一样的,只是多加了一个读取数的限制,然后我们看下代码
import (
"fmt"
"io"
"io/ioutil"
"os"
)
func main() {
r, _ := os.open("test.txt")
w, _ := os.create("write1.txt")
num, err := io.copyn(w, r, 5)
if err != nil {
fmt.println(err)
}
defer r.close()
b, _ := ioutil.readfile("write1.txt")
fmt.println(string(b)) //输出 hello
fmt.println(num) //5
}
3.func readatleast(r reader, buf []byte, min int) (n int, err error)这个函数就是从读取器中读取数据放到我们的buf中,限定了最小的读取字节数,如果我们读取的数据小于最小读取器,譬如你设定min的值是8,但是你读取的数据字节数是5就会返回一个`io.errunexpectedeof`,如果大于就会返回`io.errshortbuffer`,读取完毕会有`io.eof`~~,多讲一些哈,这个reader只要我们满足这个interface就可以用这个
type reader interface {
read(p []byte) (n int, err error)
}
其中*file就支持func (f *file) read(b []byte) (n int, err error)
import (
"fmt"
"io"
"os"
)
func main() {
r, _ := os.open("write1.txt")
b := make([]byte, 20)
defer r.close()
var total int
for {
n, err := io.readatleast(r, b, 8)
if err == nil {
fmt.println("read enough value:", string(b)) // read enough value: hello widuu
}
if err == io.errunexpectedeof { //读取了的数据小于我们限定的最小读取数据8
fmt.println("read fewer value:", string(b[0:n]))
}
if err == io.errshortbuffer{ //这个是我们设定的buf也就是b小于我们限定8
fmt.println("buf too short")
os.exit(1)
}
if err == io.eof { //读完了 输出
fmt.println("read end total", total) //read end total 11
break
}
total = total + n
}
}
4.func readfull(r reader, buf []byte) (n int, err error)这个函数和上边的函数是相似,只不过是读取len(buf)个,放在buf中
import (
"fmt"
"io"
"os"
)
func main() {
r, _ := os.open("write.txt")
b := make([]byte, 20)
num, err := io.readfull(r, b)
defer r.close()
if err == io.eof {
fmt.println("read end total", num)
}
if err == io.errunexpectedeof {
fmt.println("read fewer value:", string(b[:num])) //read fewer value: hello widuu,依然是buf长度大于读取的长度
return
}
fmt.println("read value:", string(b)) //如果b是5 就出现这里
}
5.func writestring(w writer, s string) (n int, err error)弄完读了,当然带要写了,这个函数主要是向写入目标中写入字符创,返回是写入的字节数还有error错误,主要是权限的错误,其中写入呀!都是writer这个结构就可以写入
type writer interface {
write(p []byte) (n int, err error)
}
跟read一样我们的*file是有func (f *file) write(b []byte) (n int, err error),当然其实我们的*file中就已经有wirtestring了func (f *file) writestring(s string) (ret int, err error)
import (
"fmt"
"io"
"io/ioutil"
"os"
)
func main() {
w, _ := os.openfile("write1.txt", os.o_rdwr, os.modeperm)
n, err := io.writestring(w, "ni hao ma")
if err != nil {
fmt.println(err) //当我用os.open()的时候木有权限 悲催的~~输出write write1.txt: access is denied.
}
defer w.close()
b, _ := ioutil.readfile("write1.txt")
fmt.println("write total", n) //write total 9
fmt.println(string(b)) // ni hao ma
}
6.type limitedreader
type limitedreader struct {
r reader // 读取器了
n int64 // 最大字节限制
}
只实现了一个方法func (l *limitedreader) read(p []byte) (n int, err error)其实我们不难发现这个跟我们的readatlast()就是亲兄弟的节奏
import (
"fmt"
"io"
"os"
)
func main() {
reader, _ := os.open("test.txt")
limitedreader := io.limitedreader{
r: reader,
n: 20,
}
p := make([]byte, 10)
var total int
for {
n, err := limitedreader.read(p)
if err == io.eof {
fmt.println("read total", total) //read total 11
fmt.println("read value", string(p)) //read value hello widuu
break
}
total = total + n
}
}
7.type pipereader
type pipereader struct {
// contains filtered or unexported fields
}
(1)func pipe() (*pipereader, *pipewriter)创建一个管道,并返回它的读取器和写入器,这个会在内存中进行管道同步,它的开启会io.reader然后等待io.writer的输入,没有内部缓冲,它是安全的调用read和write彼此和并行调用写
import (
"fmt"
"io"
"reflect"
)
func main() {
r, w := io.pipe()
fmt.println(reflect.typeof(r)) //*io.pipereader
fmt.println(reflect.typeof(w)) //*io.pipewriter
}
(2)func (r *pipereader) close() error管道关闭后,正在进行或后续的写入write操作返回errclosedpipe
import (
"fmt"
"io"
)
func main() {
r, w := io.pipe()
r.close()
_, err := w.write([]byte("hello widuu"))
if err == io.errclosedpipe {
fmt.println("管道已经关闭无法写入") //管道已经关闭无法写入
}
}
(3)func (r *pipereader) closewitherror(err error) error这个就是上边的r.close关闭的时候,写入器会返回错误的信息
import (
"errors"
"fmt"
"io"
)
func main() {
r, w := io.pipe()
r.close()
err := errors.new("管道符关闭了") //errors这个包我们前边已经说过了,就一个方法new不会的可以看看前边的
r.closewitherror(err)
_, err = w.write([]byte("test"))
if err != nil {
fmt.println(err) //管道符关闭了
}
}
(4)func (r *pipereader) read(data []byte) (n int, err error)标准的阅读接口,它从管道中读取数据、阻塞一直到一个写入接口关闭,如果写入端发生错误,它就会返回错误,否则返回的eof
import (
"fmt"
"io"
)
func main() {
r, w := io.pipe()
go w.write([]byte("hello widuu"))
d := make([]byte, 11)
n, _ := r.read(d) //从管道里读取数据
fmt.println(string(d))
fmt.println(n)
}
上一篇: Go语言基本的语法和内置数据类型初探
下一篇: GO语言的IO方法实例小结