• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    GO语言的IO方法实例小结

    type PipeWriter

    复制代码 代码如下:

    type PipeWriter struct {
        // contains filtered or unexported fields
    }

    (1)func (w *PipeWriter) Close() error关闭管道,关闭时正在进行的Read操作将返回EOF,若管道内仍有未读取的数据,后续仍可正常读取
    复制代码 代码如下:

    import (
     "fmt"
     "io"
    )

    func main() {
     r, w := io.Pipe()
     go w.Write([]byte("hello word"))

     data := make([]byte, 10)
     n, err := r.Read(data)
     w.Close()
     if err == io.EOF {
      fmt.Println("executing read return EOF")
      fmt.Println("executing read reads number", n)
     }
     n, _ = r.Read(data)
     fmt.Println(string(data))          //hello word
     fmt.Println("next read number", n) //next read number 0
    }


    (2)func (w *PipeWriter) CloseWithError(err error) error这个函数和read里边的CloseWithError是大同小异的,关闭管道,关闭时正在进行的Read操作将返回参数传入的异常,若管道内仍有未读取的数据,后续仍可正常读取
    复制代码 代码如下:

    import (
     "errors"
     "fmt"
     "io"
    )

    func main() {
     r, w := io.Pipe()
     go w.Write([]byte("hello widuu"))
     newerr := errors.New("your daye 突然关闭了")
     w.CloseWithError(newerr)
     data := make([]byte, 10)
     _, err := r.Read(data)
     if err != nil {
      fmt.Println(err) //your daye 突然关闭了
     }
    }


    (3)func (w *PipeWriter) Write(data []byte) (n int, err error)终于来打write了,这个是把字节切片写入管道,返回的是写入字节数和error,前边用到的太多了,随便哪一个吧
    复制代码 代码如下:

    import (
     "fmt"
     "io"
    )

    func main() {
     r, w := io.Pipe()
     go w.Write([]byte("hello widuu")) //写入的是[]byte,注意官方文档写的是,写入管道阻塞,一直到所有数据的读取结束
     data := make([]byte, 11)
     n, _ := r.Read(data)
     fmt.Println(string(data))     //hello widuu
     fmt.Println("read number", n) //read number 10
    }


    type Reader

    复制代码 代码如下:

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

    (1)func LimitReader(r Reader, n int64) Reader,我们之前就说了Reader这个结构,其实这就是对Reader的一次封装,限定了它读取字节数,其实他实现的就是io.LimitedReader{}这个结构
    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     defer f.Close()
     reader := io.LimitReader(f, 5)
     p := make([]byte, 5)
     fmt.Println(reflect.TypeOf(reader)) //*io.LimitedReader
     var total int
     for {
      n, err := reader.Read(p)
      if err == io.EOF {
       fmt.Println("read value", string(p[:total])) //read value hello
       fmt.Println(total)                           //5
       break
      }
      total = total + n
     }

    }


    (2)func MultiReader(readers ...Reader) Reader这个函数一看就知道是封装了多个readers,跟上边的方法差不多,只是封装了多个而已,当然还去除了读取的限制,我们代码给大家测试一下
    复制代码 代码如下:

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

    func main() {
     f1, _ := os.Open("test1.txt")
     f2, _ := os.Open("test.txt")
     defer f1.Close()
     defer f2.Close()
     reader := io.MultiReader(f1, f2) //*io.multiReader
     fmt.Println(reflect.TypeOf(reader))
     p := make([]byte, 10)
     var total int
     var data string
     for {
      n, err := reader.Read(p)
      if err == io.EOF {
       fmt.Println("read end", total) //read end 17
       break
      }
      total = total + n
      data = data + string(p[:n])
     }
     fmt.Println("read value", data)  //read value widuu2hello widuu
     fmt.Println("read count", total) // read count 17
    }


    (3)既然上边介绍读了,我这介绍个写吧type Write`func MultiWriter(writers ...Writer) Writer一样的作用只不过是这次换成写了
    复制代码 代码如下:

    import (
     "fmt"
     "io"
     "io/ioutil"
     "os"
    )

    func main() {
     f1, _ := os.Create("1.txt")
     f2, _ := os.Create("2.txt")
     writer := io.MultiWriter(f1, f2)
     writer.Write([]byte("widuu"))
     //千万别这么逻辑来 ,我这是测试用的哈
     r1, _ := ioutil.ReadFile("1.txt")
     r2, _ := ioutil.ReadFile("2.txt")
     fmt.Println(string(r1)) //widuu
     fmt.Println(string(r2)) //widuu
    }


    (4)func TeeReader(r Reader, w Writer) Reader这个方法有意思是从r中读取数据然后写入到w中,这个没有内部缓冲区,看下代码
    复制代码 代码如下:

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

    func main() {
     r, _ := os.Open("test.txt")
     w, _ := os.Create("test2.txt")
     reader := io.TeeReader(r, w)
     fmt.Println(reflect.TypeOf(reader)) //*io.teeReader
     p := make([]byte, 10)
     n, _ := reader.Read(p)
     fmt.Println(string(p[:n])) //hello widu
    }


    type SectionReader{}

    复制代码 代码如下:

    type SectionReader struct {
        // contains filtered or unexported fields
    }


    (1)func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader,你一看就知道了,其实就是通过这个方法获取到io.SectionReader,第一个参数读取器,第二个参数偏移量,第三个参数是读取多少

    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     sr := io.NewSectionReader(f, 2, 5)
     fmt.Println(reflect.TypeOf(sr)) //*io.SectionReader
    }


    (2)func (s *SectionReader) Read(p []byte) (n int, err error)熟悉的read()其实就是读取数据用的,大家看函数就可以理解了,因为咱们经常遇到这个上两个都写这个了~~
    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     defer f.Close()
     sr := io.NewSectionReader(f, 2, 5)
     p := make([]byte, 10)
     n, err := sr.Read(p)
     if err != nil {
      fmt.Println(err)
     }
     fmt.Println(string(p[:n])) //llo w
    }


    (3)func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)额这个跟之前的ReadAt是一样的,只不过只有一个偏移量,少了截取数,但是你要知道SectionReader做的是什么就把数据截取了,所以就不需要截取数了
    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     defer f.Close()
     sr := io.NewSectionReader(f, 2, 5)
     p := make([]byte, 10)
     n, err := sr.ReadAt(p, 1)
     if err == io.EOF {
      fmt.Println(string(p[:n])) // lo w
     }

    }


    (4)func (s *SectionReader) Seek(offset int64, whence int) (int64, error)这个是设置文件指针的便宜量的,之前我们的os里边也是有个seek的,对SectionReader的读取起始点、当前读取点、结束点进行偏移,offset 偏移量,whence 设定选项 0:读取起始点,1:当前读取点,2:结束点(不好用),其他:将抛出Seek: invalid whence异常
    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     defer f.Close()
     sr := io.NewSectionReader(f, 2, 5)
     p := make([]byte, 10)
     sr.Seek(1, 0)      //相当于起始的地址偏移1
     n, err := sr.Read(p)
     if err != nil {
      fmt.Println(err)
     }
     fmt.Println(string(p[:n])) //lo w 是不是达到了前边的ReadAt()
    }


    (5)func (s *SectionReader) Size() int64返回的是可以读取的字节数,这个不受偏移指针的影响,也不受当前读取的影响,我们具体看下代码
    复制代码 代码如下:

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

    func main() {
     f, _ := os.Open("test.txt")
     defer f.Close()
     sr := io.NewSectionReader(f, 2, 5)
     fmt.Println(sr.Size()) //5
     p := make([]byte, 10)
     sr.Seek(1, 0)    //相当于起始的地址偏移1
     n, err := sr.Read(p)
     if err != nil {
      fmt.Println(err)
     }
     fmt.Println(string(p[:n])) //lo w
     fmt.Println(sr.Size())     //5
    }

    您可能感兴趣的文章:
    • 深入解析Go语言的io.ioutil标准库使用
    • Go语言中io.Reader和io.Writer的详解与实现
    • Go语言的IO库那么多纠结该如何选择
    上一篇:Go语言编程中对文件读写的基本方法整理
    下一篇:在Go语言程序中使用gojson来解析JSON格式文件
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    GO语言的IO方法实例小结 语言,的,方法,实例,小结,