io

func Copy

1func Copy(dst Writer, src Reader) (written int64, err error)

Copy copies from src to dst until either EOF is reached on src or an error occurs. It returns the number of bytes copied and the first error encountered while copying, if any.

A successful Copy returns err == nil, not err == EOF. Because Copy is defined to read from src until EOF, it does not treat an EOF from Read as an error to be reported.

If src implements the WriterTo interface, the copy is implemented by calling src.WriteTo(dst). Otherwise, if dst implements the ReaderFrom interface, the copy is implemented by calling dst.ReadFrom(src).

1r := strings.NewReader("some io.Reader stream to be read\n")
2
3if _, err := io.Copy(os.Stdout, r); err != nil {
4	log.Fatal(err)
5}

some io.Reader stream to be read

func CopyN

1func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

CopyN copies n bytes (or until an error) from src to dst. It returns the number of bytes copied and the earliest error encountered while copying. On return, written == n if and only if err == nil.

If dst implements the ReaderFrom interface, the copy is implemented using it.

1r := strings.NewReader("some io.Reader stream to be read")
2
3if _, err := io.CopyN(os.Stdout, r, 4); err != nil {
4	log.Fatal(err)
5}

some

func Pipe

1func Pipe() (*PipeReader, *PipeWriter)

Pipe creates a synchronous in-memory pipe. It can be used to connect code expecting an io.Reader with code expecting an io.Writer.

Reads and Writes on the pipe are matched one to one except when multiple Reads are needed to consume a single Write. That is, each Write to the PipeWriter blocks until it has satisfied one or more Reads from the PipeReader that fully consume the written data. The data is copied directly from the Write to the corresponding Read (or Reads); there is no internal buffering.

It is safe to call Read and Write in parallel with each other or with Close. Parallel calls to Read and parallel calls to Write are also safe: the individual calls will be gated sequentially.

 1r, w := io.Pipe()
 2
 3go func() {
 4	fmt.Fprint(w, "some io.Reader stream to be read\n")
 5	w.Close()
 6}()
 7
 8if _, err := io.Copy(os.Stdout, r); err != nil {
 9	log.Fatal(err)
10}

some io.Reader stream to be read

func ReadAll

1func ReadAll(r Reader) ([]byte, error)

ReadAll reads from r until an error or EOF and returns the data it read. A successful call returns err == nil, not err == EOF. Because ReadAll is defined to read from src until EOF, it does not treat an EOF from Read as an error to be reported.

1r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
2
3b, err := io.ReadAll(r)
4if err != nil {
5	log.Fatal(err)
6}
7
8fmt.Printf("%s", b)

Go is a general-purpose language designed with systems programming in mind.

func ReadAtLeast

1func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)

ReadAtLeast reads from r into buf until it has read at least min bytes. It returns the number of bytes copied and an error if fewer bytes were read. The error is EOF only if no bytes were read. If an EOF happens after reading fewer than min bytes, ReadAtLeast returns ErrUnexpectedEOF. If min is greater than the length of buf, ReadAtLeast returns ErrShortBuffer. On return, n >= min if and only if err == nil. If r returns an error having read at least min bytes, the error is dropped.

 1r := strings.NewReader("some io.Reader stream to be read\n")
 2
 3buf := make([]byte, 14)
 4if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
 5	log.Fatal(err)
 6}
 7fmt.Printf("%s\n", buf)
 8
 9shortBuf := make([]byte, 3)
10if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
11	fmt.Println("error:", err)
12}
13
14longBuf := make([]byte, 64)
15if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
16	fmt.Println("error:", err)
17}

some io.Reader
error: short buffer
error: unexpected EOF

func ReadFull

1func ReadFull(r Reader, buf []byte) (n int, err error)

ReadFull reads exactly len(buf) bytes from r into buf. It returns the number of bytes copied and an error if fewer bytes were read. The error is EOF only if no bytes were read. If an EOF happens after reading some but not all the bytes, ReadFull returns ErrUnexpectedEOF. On return, n == len(buf) if and only if err == nil. If r returns an error having read at least len(buf) bytes, the error is dropped.

 1r := strings.NewReader("some io.Reader stream to be read\n")
 2
 3buf := make([]byte, 4)
 4if _, err := io.ReadFull(r, buf); err != nil {
 5	log.Fatal(err)
 6}
 7fmt.Printf("%s\n", buf)
 8
 9longBuf := make([]byte, 64)
10if _, err := io.ReadFull(r, longBuf); err != nil {
11	fmt.Println("error:", err)
12}

some
error: unexpected EOF

func WriteString

1func WriteString(w Writer, s string) (n int, err error)

WriteString writes the contents of the string s to w, which accepts a slice of bytes. If w implements StringWriter, its WriteString method is invoked directly. Otherwise, w.Write is called exactly once.

1if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
2	log.Fatal(err)
3}

Hello World

func LimitReader

1func LimitReader(r Reader, n int64) Reader

LimitReader returns a Reader that reads from r but stops with EOF after n bytes. The underlying implementation is a *LimitedReader.

1r := strings.NewReader("some io.Reader stream to be read\n")
2lr := io.LimitReader(r, 4)
3
4if _, err := io.Copy(os.Stdout, lr); err != nil {
5	log.Fatal(err)
6}

some

func MultiReader

1func MultiReader(readers ...Reader) Reader

MultiReader returns a Reader that's the logical concatenation of the provided input readers. They're read sequentially. Once all inputs have returned EOF, Read will return EOF. If any of the readers return a non-nil, non-EOF error, Read will return that error.

1r1 := strings.NewReader("first reader ")
2r2 := strings.NewReader("second reader ")
3r3 := strings.NewReader("third reader\n")
4r := io.MultiReader(r1, r2, r3)
5
6if _, err := io.Copy(os.Stdout, r); err != nil {
7	log.Fatal(err)
8}

first reader second reader third reader

func TeeReader

1func TeeReader(r Reader, w Writer) Reader

TeeReader returns a Reader that writes to w what it reads from r. All reads from r performed through it are matched with corresponding writes to w. There is no internal buffering - the write must complete before the read completes. Any error encountered while writing is reported as a read error.

1var r io.Reader = strings.NewReader("some io.Reader stream to be read\n")
2
3r = io.TeeReader(r, os.Stdout)
4
5if _, err := io.ReadAll(r); err != nil {
6	log.Fatal(err)
7}

some io.Reader stream to be read

func NewSectionReader

1func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader

NewSectionReader returns a SectionReader that reads from r starting at offset off and stops with EOF after n bytes.

func MultiWriter

1func MultiWriter(writers ...Writer) Writer

MultiWriter creates a writer that duplicates its writes to all the provided writers, similar to the Unix tee(1) command.

Each write is written to each listed writer, one at a time. If a listed writer returns an error, that overall write operation stops and returns the error; it does not continue down the list.

 1r := strings.NewReader("some io.Reader stream to be read\n")
 2
 3var buf1, buf2 strings.Builder
 4w := io.MultiWriter(&buf1, &buf2)
 5
 6if _, err := io.Copy(w, r); err != nil {
 7	log.Fatal(err)
 8}
 9
10fmt.Print(buf1.String())
11fmt.Print(buf2.String())

some io.Reader stream to be read
some io.Reader stream to be read

type ByteReader

1type ByteReader interface {
2	ReadByte() (byte, error)
3}

ByteReader is the interface that wraps the ReadByte method.

ReadByte reads and returns the next byte from the input or any error encountered. If ReadByte returns an error, no input byte was consumed, and the returned byte value is undefined.

ReadByte provides an efficient interface for byte-at-time processing. A Reader that does not implement ByteReader can be wrapped using bufio.NewReader to add this method.

type ByteScanner

1type ByteScanner interface {
2	ByteReader
3	UnreadByte() error
4}

ByteScanner is the interface that adds the UnreadByte method to the basic ReadByte method.

UnreadByte causes the next call to ReadByte to return the last byte read. If the last operation was not a successful call to ReadByte, UnreadByte may return an error, unread the last byte read (or the byte prior to the last-unread byte), or (in implementations that support the Seeker interface) seek to one byte before the current offset.

type ByteWriter

1type ByteWriter interface {
2	WriteByte(c byte) error
3}

ByteWriter is the interface that wraps the WriteByte method.

type Closer

1type Closer interface {
2	Close() error
3}

Closer is the interface that wraps the basic Close method.

The behavior of Close after the first call is undefined. Specific implementations may document their own behavior.

type LimitedReader

1type LimitedReader struct {
2	R	Reader	// underlying reader
3	N	int64	// max bytes remaining
4}

A LimitedReader reads from R but limits the amount of data returned to just N bytes. Each call to Read updates N to reflect the new amount remaining. Read returns EOF when N <= 0 or when the underlying R returns EOF.

1func (l *LimitedReader) Read(p []byte) (n int, err error)

type OffsetWriter

1type OffsetWriter struct {
2}

An OffsetWriter maps writes at offset base to offset base+off in the underlying writer.

1func (o *OffsetWriter) Seek(offset int64, whence int) (int64, error)

1func (o *OffsetWriter) Write(p []byte) (n int, err error)

1func (o *OffsetWriter) WriteAt(p []byte, off int64) (n int, err error)

type PipeReader

1type PipeReader struct {
2}

A PipeReader is the read half of a pipe.

1func (r *PipeReader) Close() error

1func (r *PipeReader) CloseWithError(err error) error

1func (r *PipeReader) Read(data []byte) (n int, err error)

type PipeWriter

1type PipeWriter struct {
2}

A PipeWriter is the write half of a pipe.

1func (w *PipeWriter) Close() error

1func (w *PipeWriter) CloseWithError(err error) error

1func (w *PipeWriter) Write(data []byte) (n int, err error)

type ReadCloser

1type ReadCloser interface {
2	Reader
3	Closer
4}

ReadCloser is the interface that groups the basic Read and Close methods.

type ReadSeekCloser

1type ReadSeekCloser interface {
2	Reader
3	Seeker
4	Closer
5}

ReadSeekCloser is the interface that groups the basic Read, Seek and Close methods.

type ReadSeeker

1type ReadSeeker interface {
2	Reader
3	Seeker
4}

ReadSeeker is the interface that groups the basic Read and Seek methods.

type ReadWriteCloser

1type ReadWriteCloser interface {
2	Reader
3	Writer
4	Closer
5}

ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.

type ReadWriteSeeker

1type ReadWriteSeeker interface {
2	Reader
3	Writer
4	Seeker
5}

ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.

type ReadWriter

1type ReadWriter interface {
2	Reader
3	Writer
4}

ReadWriter is the interface that groups the basic Read and Write methods.

type Reader

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

Reader is the interface that wraps the basic Read method.

Read reads up to len(p) bytes into p. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered. Even if Read returns n < len(p), it may use all of p as scratch space during the call. If some data is available but not len(p) bytes, Read conventionally returns what is available instead of waiting for more.

When Read encounters an error or end-of-file condition after successfully reading n > 0 bytes, it returns the number of bytes read. It may return the (non-nil) error from the same call or return the error (and n == 0) from a subsequent call. An instance of this general case is that a Reader returning a non-zero number of bytes at the end of the input stream may return either err == EOF or err == nil. The next Read should return 0, EOF.

Callers should always process the n > 0 bytes returned before considering the error err. Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors.

Implementations of Read are discouraged from returning a zero byte count with a nil error, except when len(p) == 0. Callers should treat a return of 0 and nil as indicating that nothing happened; in particular it does not indicate EOF.

Implementations must not retain p.

type ReaderAt

1type ReaderAt interface {
2	ReadAt(p []byte, off int64) (n int, err error)
3}

ReaderAt is the interface that wraps the basic ReadAt method.

ReadAt reads len(p) bytes into p starting at offset off in the underlying input source. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered.

When ReadAt returns n < len(p), it returns a non-nil error explaining why more bytes were not returned. In this respect, ReadAt is stricter than Read.

Even if ReadAt returns n < len(p), it may use all of p as scratch space during the call. If some data is available but not len(p) bytes, ReadAt blocks until either all the data is available or an error occurs. In this respect ReadAt is different from Read.

If the n = len(p) bytes returned by ReadAt are at the end of the input source, ReadAt may return either err == EOF or err == nil.

If ReadAt is reading from an input source with a seek offset, ReadAt should not affect nor be affected by the underlying seek offset.

Clients of ReadAt can execute parallel ReadAt calls on the same input source.

Implementations must not retain p.

type ReaderFrom

1type ReaderFrom interface {
2	ReadFrom(r Reader) (n int64, err error)
3}

ReaderFrom is the interface that wraps the ReadFrom method.

ReadFrom reads data from r until EOF or error. The return value n is the number of bytes read. Any error except EOF encountered during the read is also returned.

The Copy function uses ReaderFrom if available.

type RuneReader

1type RuneReader interface {
2	ReadRune() (r rune, size int, err error)
3}

RuneReader is the interface that wraps the ReadRune method.

ReadRune reads a single encoded Unicode character and returns the rune and its size in bytes. If no character is available, err will be set.

type RuneScanner

1type RuneScanner interface {
2	RuneReader
3	UnreadRune() error
4}

RuneScanner is the interface that adds the UnreadRune method to the basic ReadRune method.

UnreadRune causes the next call to ReadRune to return the last rune read. If the last operation was not a successful call to ReadRune, UnreadRune may return an error, unread the last rune read (or the rune prior to the last-unread rune), or (in implementations that support the Seeker interface) seek to the start of the rune before the current offset.

type Seeker

1type Seeker interface {
2	Seek(offset int64, whence int) (int64, error)
3}

Seeker is the interface that wraps the basic Seek method.

Seek sets the offset for the next Read or Write to offset, interpreted according to whence: SeekStart means relative to the start of the file, SeekCurrent means relative to the current offset, and SeekEnd means relative to the end (for example, offset = -2 specifies the penultimate byte of the file). Seek returns the new offset relative to the start of the file or an error, if any.

Seeking to an offset before the start of the file is an error. Seeking to any positive offset may be allowed, but if the new offset exceeds the size of the underlying object the behavior of subsequent I/O operations is implementation-dependent.

type StringWriter

1type StringWriter interface {
2	WriteString(s string) (n int, err error)
3}

StringWriter is the interface that wraps the WriteString method.

type WriteCloser

1type WriteCloser interface {
2	Writer
3	Closer
4}

WriteCloser is the interface that groups the basic Write and Close methods.

type WriteSeeker

1type WriteSeeker interface {
2	Writer
3	Seeker
4}

WriteSeeker is the interface that groups the basic Write and Seek methods.

type Writer

1type Writer interface {
2	Write(p []byte) (n int, err error)
3}

Writer is the interface that wraps the basic Write method.

Write writes len(p) bytes from p to the underlying data stream. It returns the number of bytes written from p (0 <= n <= len(p)) and any error encountered that caused the write to stop early. Write must return a non-nil error if it returns n < len(p). Write must not modify the slice data, even temporarily.

Implementations must not retain p.

type WriterAt

1type WriterAt interface {
2	WriteAt(p []byte, off int64) (n int, err error)
3}

WriterAt is the interface that wraps the basic WriteAt method.

WriteAt writes len(p) bytes from p to the underlying data stream at offset off. It returns the number of bytes written from p (0 <= n <= len(p)) and any error encountered that caused the write to stop early. WriteAt must return a non-nil error if it returns n < len(p).

If WriteAt is writing to a destination with a seek offset, WriteAt should not affect nor be affected by the underlying seek offset.

Clients of WriteAt can execute parallel WriteAt calls on the same destination if the ranges do not overlap.

Implementations must not retain p.

type WriterTo

1type WriterTo interface {
2	WriteTo(w Writer) (n int64, err error)
3}

WriterTo is the interface that wraps the WriteTo method.

WriteTo writes data to w until there’s no more data to write or when an error occurs. The return value n is the number of bytes written. Any error encountered during the write is also returned.

The Copy function uses WriterTo if available.