io.Reader interface

io.Reader interface is a basic and very frequently-used interface: 

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

For every type who satisfies the io.Reader interface, you can imagine it’s a pipe. Someone writes contents into one end of the pipe, and you can use Read() method which the type has provided to read content from the other end of the pipe. No matter it is a common file, a network socket, and so on. Only if it is compatible with io.Reader interface, I can read content of it.

Let’s see an example: 

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "log"
  7.     "os"
  8. )
  10. func main() {
  11.     file, err := os.Open("test.txt")
  12.     if err != nil {
  13.         log.Fatal(err)
  14.     }
  15.     defer file.Close()
  17.     p := make([]byte, 4)
  18.     for {
  19.         if n, err := file.Read(p); n > 0 {
  20.             fmt.Printf("Read %s\n", p[:n])
  21.         } else if err != nil {
  22.             if err == io.EOF {
  23.                 fmt.Println("Read all of the content.")
  24.                 break
  25.             } else {
  26.                 log.Fatal(err)
  27.             }
  28.         } else /* n == 0 && err == nil */ {
  29.             /* do nothing */
  30.         }
  31.     }
  32. }

You can see after issuing a read() call, there are 3 scenarios need to be considered:

(1) n > 0: read valid contents; process it;
(2) n == 0 && err != nil: if err is io.EOF, it means all the content have been read, and there is nothing left; else something unexpected happened, need to do special operations;
(3) n == 0 && err == nil: according to io package document, it means nothing happened, so no need to do anything.

Create a test.txt file which only contains 5 bytes: 

  1. # cat test.txt
  2. abcde

Executing the program, and the result is like this: 

  1. Read abcd
  2. Read e
  3. Read all of the content.

Reference:
io package document.