Black Lives Matter. Support the Equal Justice Initiative.

Source file src/io/example_test.go

Documentation: io

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package io_test
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"io"
    11  	"log"
    12  	"os"
    13  	"strings"
    14  )
    15  
    16  func ExampleCopy() {
    17  	r := strings.NewReader("some io.Reader stream to be read\n")
    18  
    19  	if _, err := io.Copy(os.Stdout, r); err != nil {
    20  		log.Fatal(err)
    21  	}
    22  
    23  	// Output:
    24  	// some io.Reader stream to be read
    25  }
    26  
    27  func ExampleCopyBuffer() {
    28  	r1 := strings.NewReader("first reader\n")
    29  	r2 := strings.NewReader("second reader\n")
    30  	buf := make([]byte, 8)
    31  
    32  	// buf is used here...
    33  	if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
    34  		log.Fatal(err)
    35  	}
    36  
    37  	// ... reused here also. No need to allocate an extra buffer.
    38  	if _, err := io.CopyBuffer(os.Stdout, r2, buf); err != nil {
    39  		log.Fatal(err)
    40  	}
    41  
    42  	// Output:
    43  	// first reader
    44  	// second reader
    45  }
    46  
    47  func ExampleCopyN() {
    48  	r := strings.NewReader("some io.Reader stream to be read")
    49  
    50  	if _, err := io.CopyN(os.Stdout, r, 4); err != nil {
    51  		log.Fatal(err)
    52  	}
    53  
    54  	// Output:
    55  	// some
    56  }
    57  
    58  func ExampleReadAtLeast() {
    59  	r := strings.NewReader("some io.Reader stream to be read\n")
    60  
    61  	buf := make([]byte, 14)
    62  	if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
    63  		log.Fatal(err)
    64  	}
    65  	fmt.Printf("%s\n", buf)
    66  
    67  	// buffer smaller than minimal read size.
    68  	shortBuf := make([]byte, 3)
    69  	if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
    70  		fmt.Println("error:", err)
    71  	}
    72  
    73  	// minimal read size bigger than io.Reader stream
    74  	longBuf := make([]byte, 64)
    75  	if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
    76  		fmt.Println("error:", err)
    77  	}
    78  
    79  	// Output:
    80  	// some io.Reader
    81  	// error: short buffer
    82  	// error: unexpected EOF
    83  }
    84  
    85  func ExampleReadFull() {
    86  	r := strings.NewReader("some io.Reader stream to be read\n")
    87  
    88  	buf := make([]byte, 4)
    89  	if _, err := io.ReadFull(r, buf); err != nil {
    90  		log.Fatal(err)
    91  	}
    92  	fmt.Printf("%s\n", buf)
    93  
    94  	// minimal read size bigger than io.Reader stream
    95  	longBuf := make([]byte, 64)
    96  	if _, err := io.ReadFull(r, longBuf); err != nil {
    97  		fmt.Println("error:", err)
    98  	}
    99  
   100  	// Output:
   101  	// some
   102  	// error: unexpected EOF
   103  }
   104  
   105  func ExampleWriteString() {
   106  	if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
   107  		log.Fatal(err)
   108  	}
   109  
   110  	// Output: Hello World
   111  }
   112  
   113  func ExampleLimitReader() {
   114  	r := strings.NewReader("some io.Reader stream to be read\n")
   115  	lr := io.LimitReader(r, 4)
   116  
   117  	if _, err := io.Copy(os.Stdout, lr); err != nil {
   118  		log.Fatal(err)
   119  	}
   120  
   121  	// Output:
   122  	// some
   123  }
   124  
   125  func ExampleMultiReader() {
   126  	r1 := strings.NewReader("first reader ")
   127  	r2 := strings.NewReader("second reader ")
   128  	r3 := strings.NewReader("third reader\n")
   129  	r := io.MultiReader(r1, r2, r3)
   130  
   131  	if _, err := io.Copy(os.Stdout, r); err != nil {
   132  		log.Fatal(err)
   133  	}
   134  
   135  	// Output:
   136  	// first reader second reader third reader
   137  }
   138  
   139  func ExampleTeeReader() {
   140  	var r io.Reader = strings.NewReader("some io.Reader stream to be read\n")
   141  
   142  	r = io.TeeReader(r, os.Stdout)
   143  
   144  	// Everything read from r will be copied to stdout.
   145  	io.ReadAll(r)
   146  
   147  	// Output:
   148  	// some io.Reader stream to be read
   149  }
   150  
   151  func ExampleSectionReader() {
   152  	r := strings.NewReader("some io.Reader stream to be read\n")
   153  	s := io.NewSectionReader(r, 5, 17)
   154  
   155  	if _, err := io.Copy(os.Stdout, s); err != nil {
   156  		log.Fatal(err)
   157  	}
   158  
   159  	// Output:
   160  	// io.Reader stream
   161  }
   162  
   163  func ExampleSectionReader_ReadAt() {
   164  	r := strings.NewReader("some io.Reader stream to be read\n")
   165  	s := io.NewSectionReader(r, 5, 17)
   166  
   167  	buf := make([]byte, 6)
   168  	if _, err := s.ReadAt(buf, 10); err != nil {
   169  		log.Fatal(err)
   170  	}
   171  
   172  	fmt.Printf("%s\n", buf)
   173  
   174  	// Output:
   175  	// stream
   176  }
   177  
   178  func ExampleSectionReader_Seek() {
   179  	r := strings.NewReader("some io.Reader stream to be read\n")
   180  	s := io.NewSectionReader(r, 5, 17)
   181  
   182  	if _, err := s.Seek(10, io.SeekStart); err != nil {
   183  		log.Fatal(err)
   184  	}
   185  
   186  	if _, err := io.Copy(os.Stdout, s); err != nil {
   187  		log.Fatal(err)
   188  	}
   189  
   190  	// Output:
   191  	// stream
   192  }
   193  
   194  func ExampleSeeker_Seek() {
   195  	r := strings.NewReader("some io.Reader stream to be read\n")
   196  
   197  	r.Seek(5, io.SeekStart) // move to the 5th char from the start
   198  	if _, err := io.Copy(os.Stdout, r); err != nil {
   199  		log.Fatal(err)
   200  	}
   201  
   202  	r.Seek(-5, io.SeekEnd)
   203  	if _, err := io.Copy(os.Stdout, r); err != nil {
   204  		log.Fatal(err)
   205  	}
   206  
   207  	// Output:
   208  	// io.Reader stream to be read
   209  	// read
   210  }
   211  
   212  func ExampleMultiWriter() {
   213  	r := strings.NewReader("some io.Reader stream to be read\n")
   214  
   215  	var buf1, buf2 bytes.Buffer
   216  	w := io.MultiWriter(&buf1, &buf2)
   217  
   218  	if _, err := io.Copy(w, r); err != nil {
   219  		log.Fatal(err)
   220  	}
   221  
   222  	fmt.Print(buf1.String())
   223  	fmt.Print(buf2.String())
   224  
   225  	// Output:
   226  	// some io.Reader stream to be read
   227  	// some io.Reader stream to be read
   228  }
   229  
   230  func ExamplePipe() {
   231  	r, w := io.Pipe()
   232  
   233  	go func() {
   234  		fmt.Fprint(w, "some io.Reader stream to be read\n")
   235  		w.Close()
   236  	}()
   237  
   238  	if _, err := io.Copy(os.Stdout, r); err != nil {
   239  		log.Fatal(err)
   240  	}
   241  
   242  	// Output:
   243  	// some io.Reader stream to be read
   244  }
   245  
   246  func ExampleReadAll() {
   247  	r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
   248  
   249  	b, err := io.ReadAll(r)
   250  	if err != nil {
   251  		log.Fatal(err)
   252  	}
   253  
   254  	fmt.Printf("%s", b)
   255  
   256  	// Output:
   257  	// Go is a general-purpose language designed with systems programming in mind.
   258  }
   259  

View as plain text