What is io.Reader Interface in Go: Simple Explanation and Example

The io.Reader interface in Go represents any type that can read a stream of bytes. It defines a single method Read(p []byte) (n int, err error) which reads data into a byte slice and returns the number of bytes read and an error if any.

How It Works

Think of io.Reader as a simple machine that takes a box (a byte slice) and fills it with data from somewhere, like a file, network, or memory. You just ask it to fill your box, and it tells you how much it put in and if it had any trouble.

This interface only requires one method, Read, which makes it very flexible. Any data source that can provide bytes can implement this interface, so you can use the same code to read from many different places without changing it.

It’s like having a universal plug that fits many sockets. You just need to know how to ask for data, and the io.Reader interface makes sure you can do that in a consistent way.

Example

This example shows how to use io.Reader to read data from a string. The strings.NewReader function returns a reader that reads from the string.

go

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	reader := strings.NewReader("Hello, Go io.Reader!")
	buf := make([]byte, 8) // create a buffer to hold bytes

	for {
		n, err := reader.Read(buf) // read into buffer
		if err == io.EOF {
			break // end of data
		}
		if err != nil {
			fmt.Println("Error reading:", err)
			return
		}
		fmt.Print(string(buf[:n])) // print bytes read
	}
}

Output

Hello, Go io.Reader!

When to Use

Use io.Reader whenever you want to read data from any source without worrying about where it comes from. It is perfect for reading files, network connections, or even in-memory data in a uniform way.

For example, if you write a function that processes data, accepting an io.Reader lets your function work with files, HTTP responses, or custom data streams without changing the code.

This makes your programs more flexible and easier to test because you can swap real data sources with fake ones that also implement io.Reader.

Key Points

• io.Reader is a simple interface with one method: Read([]byte) (int, error).
• It abstracts reading data from many sources in the same way.
• Many Go standard library types implement io.Reader, like files, buffers, and network connections.
• Using io.Reader makes your code flexible and easy to test.

Key Takeaways

io.Reader defines a standard way to read bytes from any data source.

It requires implementing a single method Read([]byte) (int, error).

Using io.Reader makes your code work with files, networks, and more without changes.

Many Go types implement io.Reader, enabling flexible and reusable code.

Accepting io.Reader in functions improves testing and abstraction.