解释Go中常见的I/O模式

在这篇文章中，我想介绍一下常见的I/O（输入和输出）模式。我想在这篇文章中用浅显的语言澄清这些概念，这样人们就可以在他们的应用程序中使用优雅的Go I/O API。
让我们看看开发人员在日常生活中需要的常见用例。

写到标准输出

每个Go编程教程教给你的最常见的例子：

package mainimport "fmt"func main() {fmt.Println("Hello World")
}

但是，没有人告诉你上述代码是这个例子的简化版：

package mainimport ("fmt""os"
)func main() {fmt.Fprintln(os.Stdout, "Hello World")
}

这里发生了什么？我们有一个额外的包导入，叫做os，并且使用了fmt包中一个叫做Fprintln的方法。Fprintln方法接收一个io.Writer类型和一个要写入的字符串。os.Stdout满足io.Writer接口。
这个例子很好，可以扩展到除os.Stdout以外的任何写程序。

写到定制的writer

你学会了如何向os.stdout写入数据。让我们创建一个自定义writer并在那里存储一些信息。我们可以通过初始化一个空的缓冲区并向其写入内容来实现：

package mainimport ("bytes""fmt"
)func main() {// Empty buffer (implements io.Writer)var b bytes.Bufferfmt.Fprintln(&b, "Hello World") // Don't forget &// Optional: Check the contents storedfmt.Println(b.String()) // Prints `Hello World`
}

这个片段实例化了一个空缓冲区，并将其作为Fprintln方法的第一个参数（io.Writer）。

同时写给多个writer

有时，人们需要将一个字符串写入多个writer中。我们可以使用io包中的MultiWriter方法轻松做到这一点。

package mainimport ("bytes""fmt""io"
)func main() {// Two empty buffersvar foo, bar bytes.Buffer// Create a multi writermw := io.MultiWriter(&foo, &bar)// Write message into multi writerfmt.Fprintln(mw, "Hello World")// Optional: verfiy data stored in buffersfmt.Println(foo.String())fmt.Println(bar.String())
}

在上面的片段中，我们创建了两个空的缓冲区，叫做foo和bar。我们将这些writer传递给一个叫做io.MultiWriter的方法，以获得一个组合写入器。消息Hello World将在内部同时被写入foo和bar中。

创建一个简单的reader

Go提供了io.Readerinterface来实现一个I/O reader。reader 不进行读取，但为他人提供数据。它是一个临时的信息仓库，有许多方法，如WriteTo, Seek等。
让我们看看如何从一个字符串创建一个简单的 reader:

package mainimport ("fmt""io""strings"
)func main() {// Create a new reader (Readonly)r := strings.NewReader("Hello World")// Read all content from readerb, err := io.ReadAll(r)if err != nil {panic(err)}// Optional: verify datafmt.Println(string(b))
}

这段代码使用strings.NewReader方法创建了一个新的 reader。该 reader 拥有io.Reader接口的所有方法。我们使用io.ReadAll从 reader 中读取内容，它返回一个字节切片。最后，我们将其打印到控制台。
注意：os.Stdin是一个常用的 reader，用于收集标准输入。

一次性从多个 reader 上读取数据

与io.MultiWriter类似，我们也可以创建一个io.MultiReader来从多个 reader 那里读取数据。数据会按照传递给io.MultiReader的读者的顺序依次收集。这就像一次从不同的数据存储中收集信息，但要按照给定的顺序。

package mainimport ("fmt""io""strings"
)func main() {// Create two readersfoo := strings.NewReader("Hello Foo\n")bar := strings.NewReader("Hello Bar")// Create a multi readermr := io.MultiReader(foo, bar)// Read data from multi readerb, err := io.ReadAll(mr)if err != nil {panic(err)}// Optional: Verify datafmt.Println(string(b))
}

代码很简单，创建两个名为foo和bar的 reader，并试图从它们中创建一个MultiReader。我们可以使用io.Readall来读取MultiReader的内容，就像一个普通的 reader。
现在我们已经了解了 reader 和 writer，让我们看看从 reader 复制数据到 writer 的例子。接下来我们看到复制数据的技术。
注意：不要对大的缓冲区使用io.ReadAll，因为它们会消耗尽内存。

将数据从 reader 复制到 writer

再次对定义的理解：
reader：我可以从谁那里复制数据
writer：我可以把数据写给谁？我可以向谁写数据
这些定义使我们很容易理解，我们需要从一个 reader（字符串阅读器）加载数据，并将其转储到一个 writer（如os.Stdout或一个缓冲区）。这个复制过程可以通过两种方式发生：

reader 将数据推送给 writer
writer 从 reader 中拉出数据

reader 将数据推送给 writer

这一部分解释了第一种拷贝的变化，即 reader 将数据推送到 writer 那里。它使用reader.WriteTo(writer)的API。

package mainimport ("bytes""fmt""strings"
)func main() {// Create a readerr := strings.NewReader("Hello World")// Create a writervar b bytes.Buffer// Push datar.WriteTo(&b) // Don't forget &// Optional: verify datafmt.Println(b.String())
}

在代码中，我们使用WriteTo方法从一个名为r的 reader 那里把内容写进写 writer b。在下面的例子中，我们看到一个 writer 如何主动地从一个 reader 那里获取信息。

writer 从 reader 中拉出数据

方法writer.ReadFrom(reader)被一个 writer 用来从一个给定的 reader 中提取数据。让我们看一个例子：

package mainimport ("bytes""fmt""strings"
)func main() {// Create a readerr := strings.NewReader("Hello World")// Create a writervar b bytes.Buffer// Pull datab.ReadFrom(r)// Optional: verify datafmt.Println(b.String())
}

该代码看起来与前面的例子相似。无论你是作为 reader 还是 writer，你都可以选择变体1或2来复制数据。现在是第三种变体，它比较干净。

使用 io.Copy

io.Copy是一个实用的函数，它允许人们将数据从一个 reader 移到一个 writer。
让我们看看它是如何工作的：

package mainimport ("bytes""fmt""io""strings"
)func main() {// Create a readerr := strings.NewReader("Hello World")// Create a writervar b bytes.Buffer// Copy data_, err := io.Copy(&b, r) // Don't forget &if err != nil {panic(err)}// Optional: verify datafmt.Println(b.String())
}

io.Copy的第一个参数是Writer（目标），第二个参数是Reader（源），用于复制数据。
每当有人将数据写入 writer 时，你希望有信息可以被相应的 reader 读取。这就出现了管道的概念。

用io.Pipe创建一个数据管道

io.Pipe返回一个 reader 和一个 writer，向 writer 中写入数据会自动允许程序从 reader 中消费数据。它就像一个Unix的管道。
你必须把写入逻辑放到一个单独的goroutine中，因为管道会阻塞 writer，直到从 reader 中读取数据，而且 reader 也会被阻塞，直到 writer 被关闭。

package mainimport ("fmt""io"
)func main() {pr, pw := io.Pipe()// Writing data to writer should be in a go-routine// because pipe is synchronous.go func() {defer pw.Close() // Important! To notify writing is donefmt.Fprintln(pw, "Hello World")}()// Code is blocked until someone writes to writer and closes itb, err := io.ReadAll(pr)if err != nil {panic(err)}// Optional: verify datafmt.Println(string(b))
}

该代码创建了一个管道reader和管道writer。我们启动一个程序，将一些信息写入管道writer并关闭它。我们使用io.ReadAll方法从管道reader中读取数据。如果你不启动一个单独的程序（写或读，都是一个操作），程序将陷入死锁。
我们在下一节讨论管道的一个更实际的使用案例。

用io.Pipe、io.Copy和io.MultiWriter捕捉函数的stdout到一个变量中。

假设我们正在构建一个CLI应用程序。作为这个过程的一部分，我们创建一个函数产生的标准输出（到控制台），并将相同的信息赋值到一个变量中。我们怎样才能做到这一点呢？我们可以使用上面讨论的技术来创建一个解决方案。

package mainimport ("bytes""fmt""io""os"
)// Your function
func foo(w *io.PipeWriter) {defer w.Close()// Write a message to pipe writerfmt.Fprintln(w, "Hello World")
}func main() {// Create a pipepr, pw := io.Pipe()// Pass writer to functiongo foo(pw)// Variable to get standard output of functionvar b bytes.Buffer// Create a multi writer that is a combination of// os.Stdout and our variable byte buffermw := io.MultiWriter(os.Stdout, &b)// Copies reader content to standard output_, err := io.Copy(mw, pr)if err != nil {panic(err)}// Optional: verify datafmt.Println(b.String())
}