Communication

Good communication is as stimulating as black coffee, and just as hard to sleep after.

– Anne Morrow Lindbergh

In this chapter we are going to look at the building blocks in Go forcommunicating with the outside world. We will look at files, directories,networking and executing other programs. Central to Go’s I/O are the interfacesio.Reader and io.Writer. The io.Reader interface specifies one methodRead(p []byte) (n int, err err).

Reading from (and writing to) files is easy in Go. This programonly uses the os package to read data from the file /etc/passwd.

  1. package main
  3. import (
  4.     "log"
  5.     "os"
  6. )
  8. func main() {
  9.     buf := make([]byte, 1024)
  10.     f, e := os.Open("/etc/passwd") 1
  11.     if e != nil {
  12.         log.Fatalf(e)
  13.     }
  14.     defer f.Close() 2
  15.     for {
  16.         n, e := f.Read(buf) 3
  17.         if e != nil {
  18.             log.Fatalf(e) 4
  19.         }
  20.         if n == 0 { 5
  21.             break
  22.         }
  23.         os.Stdout.Write(buf[:n]) 6
  24.     }
  25. }

We open the file at 1 with os.Open that returns a os.Fileos.File implements io.Reader and io.Writer interface.After the Open we directly put the f.Close() which we defer until the functionreturn. At 3 we call Read on f and read up to 1024 bytes at the time. If anythingfails we bail out at 4. If the number of bytes read is 0 we’ve read the end of thefile 5. And at 6 we output the buffer to standard output.

If you want to use buffered I/O there is thebufio package:

  1. package main
  3. import (
  4.     "bufio"
  5.     "log"
  6.     "os"
  7. )
  9. func main() {
  10.     buf := make([]byte, 1024)
  11.     f, e := os.Open("/etc/passwd") 1
  12.     if e != nil {
  13.         log.Fatalf(e)
  14.     }
  15.     defer f.Close()
  16.     r := bufio.NewReader(f) 2
  17.     w := bufio.NewWriter(os.Stdout)
  18.     defer w.Flush() 3
  19.     for {
  20.         n, e := r.Read(buf) 4
  21.         if e != nil {
  22.             log.Fatalf(e)
  23.         }
  24.         if n == 0 {
  25.             break
  26.         }
  27.         w.Write(buf[0:n]) 5
  28.     }
  29. }

Again, we open 1 the file. Then at 2 weTurn f into a buffered Reader. NewReader expects an io.Reader, so you this will work.Then at 4 we read and at 5 we write. We also call Flush() at 3 to flush all output.This entire program could be optimized further by using io.Copy.