Decorate types to implement io.Reader interface

The io package has provided a bunch of handy read functions and methods, but unfortunately, they all require the arguments satisfy io.Reader interface. See the following example: 

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6. )
  8. func main() {
  9.     s := "Hello, world!"
  10.     p := make([]byte, len(s))
  11.     if _, err := io.ReadFull(s, p); err != nil {
  12.         fmt.Println(err)
  13.     } else {
  14.         fmt.Printf("%s\n", p)
  15.     }
  16. }

Compile above program and an error is generated: 

  1. read.go:11: cannot use s (type string) as type io.Reader in argument to io.ReadFull:
  2.     string does not implement io.Reader (missing Read method)

The io.ReadFull function requires the argument should be compliance with io.Reader, but string type doesn’t provide Read() method, so we need to do some tricks on s variable. Modify io.ReadFull(s, p) into io.ReadFull(strings.NewReader(s), p): 

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "strings"
  7. )
  9. func main() {
  10.     s := "Hello, world!"
  11.     p := make([]byte, len(s))
  12.     if _, err := io.ReadFull(strings.NewReader(s), p); err != nil {
  13.         fmt.Println(err)
  14.     } else {
  15.         fmt.Printf("%s\n", p)
  16.     }
  17. }

This time, the compilation is OK, and the running result is: 

  1. Hello, world!

strings.NewReader function converts a string into a strings.Reader struct which supplies a read method: 

  1. func (r *Reader) Read(b []byte) (n int, err error)

Besides string, another common operation is to use bytes.NewReader to convert a byte slice into a bytes.Reader struct which satisfies io.Reader interface. Do some modifications on the above example: 

  1.  package main
  3. import (
  4.     "bytes"
  5.     "fmt"
  6.     "io"
  7.     "strings"
  8. )
  10. func main() {
  11.     s := "Hello, world!"
  12.     p := make([]byte, len(s))
  13.     if _, err := io.ReadFull(strings.NewReader(s), p); err != nil {
  14.         fmt.Println(err)
  15.     }
  17.     r := bytes.NewReader(p)
  18.     if b, err := r.ReadByte(); err != nil {
  19.         fmt.Println(err)
  20.     } else {
  21.         fmt.Printf("%c\n", b)
  22.     }
  23. }

bytes.NewReader converts the p slice into a bytes.Reader struct. The output is like this: 

  1. H