golang IO streaming

最新推荐文章于 2023-06-13 18:14:30 发布
最新推荐文章于 2023-06-13 18:14:30 发布
阅读量187 收藏
点赞数
文章标签： golang 网络
原文链接：http://www.cnblogs.com/linyihai/p/10721193.html
版权

IO Streaming

Streaming IO in Go，引用此文，略有修改

io.Reader和io.Writer

io.Reader接口定义了从传输缓存读取数据

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

Read方法接受一个[]byte作为读取数据后的接收者，返回读取的字节数n和错误err，当读尽缓存内容时，err为io.EOF。
Read方法的读取机制

  1. 尽可能读取len(p)字节到p
  2. 调用Read()后，n可能比len(p)小
  3. 如果出现错误，read()仍可能返回缓冲区p中的n个字节。例如，读取突然关闭的TCP套接字。根据您的使用，您可以选择将字节保持在p中或重试。
  4. 当Read()读尽数据后，可能返回非零的n和err=io.EOF。甚至出现返回非零n和err=nil的情况，但是接下来的Read()方法调用一定返回n=0, err=io.EOF
  5. 当n=0，err=nil时，并不意味着读取数据完毕，接下来的Read()可能返回更多的数据。

综上，实现Read()方法还是比较棘手的，幸好标准库有好多实现了io.Reader的接口。

strings.NewReader
// NewReader returns a new Reader reading from s. 
// It is similar to bytes.NewBufferString 
// but more efficient and read-only.
func NewReader(s string) *Reader

func main() {
    reader := strings.NewReader("Clear is better than clever")
    p := make([]byte, 4)
    
    for {
        n, err := reader.Read(p)
        if err != nil{
            if err == io.EOF {
            fmt.Println(string(p[:n])) //should handle any remainding bytes.
            break
            }
            fmt.Println(err)
            os.Exit(1)
        }
        fmt.Println(string(p[:n]))
    }
}
自定义io.Reader

实现Read()方法，去除非字母

type alphaReader struct {
    src string
    cur int
}

func newAlphaReader(src string) *alphaReader {
    return &alphaReader{src: src}
}

func alpha(r byte) byte {
    if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') {
        return r
    }
    return 0
}

func (a *alphaReader) Read(p []byte) (int, error) {
    if a.cur >= len(a.src) {
        return 0, io.EOF
    }

    x := len(a.src) - a.cur
    n, bound := 0, 0
    if x >= len(p) {
        bound = len(p)
    } else if x <= len(p) {
        bound = x
    }

    buf := make([]byte, bound)
    for n < bound {
        if char := alpha(a.src[a.cur]); char != 0 {
            buf[n] = char
        }
        n++
        a.cur++
    }
    copy(p, buf) // 使用copy方法，保证切片每次读取指定大小的内容
    return n, nil
}

func main() {
    reader := newAlphaReader("Hello! It's 9am, where is the sun?")
    p := make([]byte, 4)
    for {
        n, err := reader.Read(p)
        if err == io.EOF {
            break
        }
        fmt.Print(string(p[:n]))
    }
    fmt.Println()
}

借助标准库的io.Reader实现来简化代码

type alphaReader struct {
    reader io.Reader
}

func newAlphaReader(reader io.Reader) *alphaReader {
    return &alphaReader{reader: reader}
}

func alpha(r byte) byte {
    if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') {
        return r
    }
    return 0
}

func (a *alphaReader) Read(p []byte) (int, error) {
    n, err := a.reader.Read(p)
    if err != nil {
        return n, err
    }
    buf := make([]byte, n)
    for i := 0; i < n; i++ {
        if char := alpha(p[i]); char != 0 {
            buf[i] = char
        }
    }

    copy(p, buf)
    return n, nil
}

func main() {
    // use an io.Reader as source for alphaReader
    reader := newAlphaReader(strings.NewReader("Hello! It's 9am, where is the sun?"))
    p := make([]byte, 4)
    for {
        n, err := reader.Read(p)
        if err == io.EOF {
            break
        }
        fmt.Print(string(p[:n]))
    }
    fmt.Println()
}

与读取文件的io.Reader结合

func main() {
    // use an os.File as source for alphaReader
    file, err := os.Open("./alpha_reader3.go")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()
    
    reader := newAlphaReader(file)
    p := make([]byte, 4)
    for {
        n, err := reader.Read(p)
        if err == io.EOF {
            break
        }
        fmt.Print(string(p[:n]))
    }
    fmt.Println()
}
io.Writer
type Writer interface {
    Write(p []byte) (n int, err error)
}

Write方法接受一个[]byte作为输入

func main() {
    proverbs := []string{
        "Channels orchestrate mutexes serialize",
        "Cgo is not Go",
        "Errors are values",
        "Don't panic",
    }
    var writer bytes.Buffer

    for _, p := range proverbs {
        n, err := writer.Write([]byte(p))
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        if n != len(p) {
            fmt.Println("failed to write data")
            os.Exit(1)
        }
    }

    fmt.Println(writer.String())
}
实现自定义io.Writer
type chanWriter struct {
    ch chan byte
}

func newChanWriter() *chanWriter {
    return &chanWriter{make(chan byte, 1024)}
}

func (w *chanWriter) Chan() <-chan byte {
    return w.ch
}

func (w *chanWriter) Write(p []byte) (int, error) {
    n := 0
    for _, b := range p {
        w.ch <- b
        n++
    }
    return n, nil
}

func (w *chanWriter) Close() error {
    close(w.ch)
    return nil
}

func main() {
    writer := newChanWriter()
    go func() {
        defer writer.Close()
        writer.Write([]byte("Stream "))
        writer.Write([]byte("me!"))
    }()
    for c := range writer.Chan() {
        fmt.Printf("%c", c)
    }
    fmt.Println()
}

chanWriter也实现了io.Closer, 调用writer.Close()关闭channel，避免chanWriter.Write
方法一直等待channel。

os.File

亦实现了io.Writer和io.Reader接口，因此向文件写文件可以调用writer.Write([]byte), os.Create返回*os.File

func main() {
    proverbs := []string{
        "Channels orchestrate mutexes serialize\n",
        "Cgo is not Go\n",
        "Errors are values\n",
        "Don't panic\n",
    }
    // func Create(name string) (*File, error)
    file, err := os.Create("./proverbs.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()

    for _, p := range proverbs {
        n, err := file.Write([]byte(p))
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        if n != len(p) {
            fmt.Println("failed to write data")
            os.Exit(1)
        }
    }
    fmt.Println("file write done")
}

os.Open返回的*os.File是只读的

func main() {
    // 如果需要读写文件，使用os.OpenFile
    //  file, err := os.OpenFile("./proverbs.txt", os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
    file, err := os.Open("./proverbs.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()

    p := make([]byte, 4)
    for {
        n, err := file.Read(p)
        if err == io.EOF {
            break
        }
        fmt.Print(string(p[:n]))
    }
}
os.Stdout, os.Stdin, os.Stderr 其实也是*os.File
func main() {
    proverbs := []string{
        "Channels orchestrate mutexes serialize\n",
        "Cgo is not Go\n",
        "Errors are values\n",
        "Don't panic\n",
    }

    for _, p := range proverbs {
        n, err := os.Stdout.Write([]byte(p))
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        if n != len(p) {
            fmt.Println("failed to write data")
            os.Exit(1)
        }
    }
}
io.Copy 方便的将流数据拷贝到目标reader
func main() {
    proverbs := new(bytes.Buffer)
    proverbs.WriteString("Channels orchestrate mutexes serialize\n")
    proverbs.WriteString("Cgo is not Go\n")
    proverbs.WriteString("Errors are values\n")
    proverbs.WriteString("Don't panic\n")

    file, err := os.Create("./proverbs.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()

    // copy from reader data into writer file
    if _, err := io.Copy(file, proverbs); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println("file created")
}
// 或者
func main() {
    file, err := os.Open("./proverbs.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()

    if _, err := io.Copy(os.Stdout, file); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}
io.WriteString()

可以方便地将字符串写入到writer

func main() {
    file, err := os.Create("./magic_msg.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()
    if _, err := io.WriteString(file, "Go is fun!"); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}
Pipe writers and readers

输入io.PipeWriter和io.PipeReader模型IO操作，如在内存管道中。数据被写入管道的写入端，并使用单独的GO例程在管道的读取器端读取数据。

func main() {
    proverbs := new(bytes.Buffer)
    proverbs.WriteString("Channels orchestrate mutexes serialize\n")
    proverbs.WriteString("Cgo is not Go\n")
    proverbs.WriteString("Errors are values\n")
    proverbs.WriteString("Don't panic\n")

    piper, pipew := io.Pipe()

    // write in writer end of pipe
    go func() {
        defer pipew.Close()
        io.Copy(pipew, proverbs)
    }()

    // read from reader end of pipe.
    io.Copy(os.Stdout, piper)
    piper.Close()
}
Buffered IO

GO通过包bufio支持缓冲IO，这使得使用文本内容更加容易。例如，下面的程序读取以值‘\n’分隔的逐行文件的内容。

func main() {
    file, err := os.Open("./planets.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer file.Close()
    reader := bufio.NewReader(file)

    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                break
            } else {
                fmt.Println(err)
                os.Exit(1)
            }
        }
        fmt.Print(line)
    }

}
Util package

包ioutil是io的一个子包，它为IO提供了一些方便的功能。例如，以下代码使用函数ReadFile将文件的内容加载到[]byte中

package main

import (
  "io/ioutil"
   ...
)

func main() {
    bytes, err := ioutil.ReadFile("./planets.txt")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Printf("%s", bytes)
}

还有其他IO Stream 操作

  • file IO
  • buffered IO
  • network IO
  • formatted IO

转载于:https://www.cnblogs.com/linyihai/p/10721193.html

weixin_30258901
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【一天一门编程语言】设计一套Go语言中的 Stream API 接口代码实现
禅与计算机程序设计艺术
02-26 2万+
Stream API 是一种在 Java 8 中引入的新的功能，它的目的是为了更好地处理集合数据，它可以有效地提高程序的性能。Stream API 主要用于处理集合数据，它提供了一组方法来对集合进行过滤、排序、转换等操作，并且可以将多个操作连接起来，形成一个流水线，从而可以极大地提高集合数据处理的性能。
go-stream:Java Stream API的golang实现
04-25
流 go-stream在golang中提供Java Stream API类似于流操作 用法 package main import ( "github.com/aagu/go-stream" ) func main () { ints := [] int { 1 , 2 , 3 , 4 , 5 , 6 , 7 } stream . New ( ints ). Filter ( func ( i interface {}) bool { return i .( int ) % 2 == 0 }). FlatMap ( func ( i interface {}) [] interface {} { return [] interface {}{ i , i .( int ) + 2 } }). Distinct (). ForEach ( func ( i i
Golang基础(IO流、反射)
qq_31387691的博客
10-21 1025
一.输入流 流(stream)是应用程序和外部资源进行数据交互的纽带 流分为输入流和输出流,输入和输出都是相对于程序,把外部数据传入到程序中叫做输入,反之叫做输出流 输入流(Input Stream),输入流(Output Stream) 平时所说的I/O流 在Go语言标准库中io包下是Reader接口表示输入流,只要实现这个接口就属于输入流 // Reader is the interface that wraps the basic Read method. /
golang java8_用go语言实现类似java8的Stream
weixin_35756373的博客
02-13 1715
JDK8 Stream 是一个支持泛型和函数式数据流，使用起来非常强大方便。最近在学习 go 语言我就用 go 模仿了一下类似的功能，由于 go 对泛型、函数式的支持比较有限，感觉泛型和函数式这一块实现起来有些别扭，可能是我不会用，不当之处请高手指点。Stream 具备部分与整体一致的结构设计，可很方便用来实现各种递归算法，尾部有一个Nil作为递归跳出点。“左折叠”和“右折叠” 是非常强大的操作，...
golang日志服务器_golang HTTP 服务器 处理 日志/Stream流的操作
weixin_39907526的博客
12-20 228
目前，我开发 HTTP 服务， 用的是 beego框架， 方便了很多。但是， 有时候，还是会遇到一些 特殊的场景。比如： 过滤日志。这应该是一种典型的stream，同时数据量也适中， 不会有人，为了这个， 就用一些很重的框架。可以这样直观的描述这个 逻辑其他组件 产生 log||\ /我的组件，业务处理||\ /用户， http client这种情景下， 有几个特殊点：1. 难以用 string，...
Golang之Stream流处理
weixin_42526674的博客
03-02 2675
Golang类似java的Stream流处理，利用channel为媒介，不断的将数据写入到channel中或者用协程去接收处理 来达到异步非阻塞的效果
谈谈对Golang IO读写的困惑
09-16
主要介绍了谈谈对Golang IO读写的困惑，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
shapeio:Golang io.Reader和io.Writer的流量整形器
05-09
形状Golang io.Reader和io.Writer的流量整形器import "github.com/fujiwara/shapeio"func ExampleReader () {// example for downloading http body with rate limit.resp , _ := http . Get ( ...
用于golang（实时应用程序框架）的socket.io库。-Golang开发
05-26
go-socket.io go-socket.io是Golang中Socket.IO的实现，Golang是一个实时应用程序框架。 当前，该库支持Socket.IO客户端的1.4版本。 它支持房间和名称空间。 Go 1 go-socket.io go-socket.io是Golang中Socket.IO的...
Golang-Video-Streaming
05-13
Golang视频流这是使用Go语言实现的视频分发站点。它是从头开始实现的，以学习体系结构和后端。 后端首先，在视频分发站点上，似乎要分发的视频是按照诸如MPEG-DASH和HLS之类的标准分成小块的，并为每个比特率准备的...
go 输入输出流(io)
tianlongtc的博客
05-02 4003
io 包为 I/O 原语提供了基本的接口。它主要包装了这些原语的已有实现。由于这些接口和原语以不同的实现包装了低级操作，因此除非另行通知，否则客户端不应假定它们对于并行执行是安全的。在 io 包中最重要的是两个接口：Reader 和 Writer 接口。本章所提到的各种 IO 包，都跟这两个接口有关，也就是说，只要实现了这两个接口，它就有了 IO 的功能。1.1. Reader 接口Reader ...
用go语言实现类似java8的Stream
weixin_30293135的博客
08-30 1253
JDK8 Stream 是一个支持泛型和函数式数据流，使用起来非常强大方便。最近在学习 go 语言我就用 go 模仿了一下类似的功能，由于 go 对泛型、函数式的支持比较有限，感觉泛型和函数式这一块实现起来有些别扭，可能是我不会用，不当之处请高手指点。 Stream 具备部分与整体一致的结构设计，可很方便用来实现各种递归算法，尾部有一个Nil作为递归跳出点。“左折叠”和“右折叠” 是非...
go 输入输出流(ioutil)
tianlongtc的博客
05-02 3638
虽然 io 包提供了不少类型、方法和函数，但有时候使用起来不是那么方便。比如读取一个文件中的所有内容。为此，标准库中提供了一些常用、方便的IO操作函数。说明：这些函数使用都相对简单，一般就不举例子了。1.1. NopCloser 函数有时候我们需要传递一个io.ReadCloser的实例，而我们现在有一个io.Reader的实例，比如：strings.Reader，这个时候NopCloser就派上...
hadoop streaming编程和golang实现mr demo
天天water的专栏
12-01 4438
hadoop streaming是什么？为什么要用hadoop streaming？hadoop streaming怎么用？接下来我们就来解决这些问题。 1、首先，hadoop streaming是一种编程工具，它是由hadoop提供的。 2、为什么要用hadoop streaming呢？ hadoop框架是用java语言写的，也就是说，hadoop框架中运行的所有应用程序都要用java语言来写才能正常地在hadoop集群中运行。那么问题来了，如果有些开发者就是不会java语言，但是又想使用mapredu
Golang包 （二）
chinusyan的专栏
09-19 974
Golang 包 -- encoding、syscall、strings、crypto、bytes、binary、math、gob、fs、hash
【Go泛型】用Go 写了个Stream处理框架堪比Java-Stream
bingju328的博客
04-06 1194
Go中没有合适的类似于Java Stream的处理框架，这里自行根据Go语言特性及泛型实现了个，用起来和Java Stream一样丝滑，就是有点费笔水。。。
golang类似java8 stream 流式处理 的工具代码，带有泛型，改了go-zero（没有泛型）某个模块的代码，可以直接复制使用
weixin_42349879的博客
06-13 281
【代码】golang类似java8 stream的工具代码，可以直接复制使用。
Golang：io包中的接口
weixin_40108561的博客
04-12 294
回顾 之前学习了strings.Builder，strings.Reader，bytes.Buffer。 strings.Builder类型主要用于构建字符串，他的指针类型实现的接口有io.Writer、io.ByteWriter和fmt.Stringer。另外，它其实还实现了一个io包的包级私有接口，io.StringWriter。 strings.Reader类型主要用于读取字符串 ...
Go语言学习教程（十三）
小陈工的博客
06-29 278
一、os包内容介绍* 使用os包中内容进行操作系统文件或目录* File结构体表示操作系统文件(夹)* 操作系统的文件都是有权限控制的,包含可读,可写等,在os包中FileMode表示文件权限,本质是uint32,可取值都以常量形式提供* FIleInfo是一个interface表示文件的信息* 在获取系统资源时资源路径分为相对路径和绝对路径* 相对路径:在Go语言中相对路径用于是GOPATH,也就是项目的根目录* 绝对路径:磁盘根目录开始表示资源详细路径的描述* 创建文件夹 /* 如果文件夹已
golang io库
最新发布
06-06
`golang` 的 `io` 库是 Go 语言标准库中的核心部分，它提供了处理输入输出（I/O）操作的功能，包括文件系统、网络连接、数据流等。`io` 包主要包括以下几个关键组件： 1. **Reader** 和 **Writer** 接口：这两个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值