Involved Source Files Package io provides basic interfaces to I/O primitives.
Its primary job is to wrap existing implementations of such primitives,
such as those in package os, into shared public interfaces that
abstract the functionality, plus some other related primitives.
Because these interfaces and primitives wrap lower-level operations with
various implementations, unless otherwise informed clients should not
assume they are safe for parallel execution.multi.gopipe.go
Code Examples
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r1 := strings.NewReader("first reader\n")
r2 := strings.NewReader("second reader\n")
buf := make([]byte, 8)
// buf is used here...
if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
log.Fatal(err)
}
// ... reused here also. No need to allocate an extra buffer.
if _, err := io.CopyBuffer(os.Stdout, r2, buf); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read")
if _, err := io.CopyN(os.Stdout, r, 4); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
lr := io.LimitReader(r, 4)
if _, err := io.Copy(os.Stdout, lr); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r1 := strings.NewReader("first reader ")
r2 := strings.NewReader("second reader ")
r3 := strings.NewReader("third reader\n")
r := io.MultiReader(r1, r2, r3)
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
var buf1, buf2 strings.Builder
w := io.MultiWriter(&buf1, &buf2)
if _, err := io.Copy(w, r); err != nil {
log.Fatal(err)
}
fmt.Print(buf1.String())
fmt.Print(buf2.String())
}
package main
import (
"fmt"
"io"
"log"
"os"
)
func main() {
r, w := io.Pipe()
go func() {
fmt.Fprint(w, "some io.Reader stream to be read\n")
w.Close()
}()
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
b, err := io.ReadAll(r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", b)
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
buf := make([]byte, 14)
if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", buf)
// buffer smaller than minimal read size.
shortBuf := make([]byte, 3)
if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
fmt.Println("error:", err)
}
// minimal read size bigger than io.Reader stream
longBuf := make([]byte, 64)
if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
fmt.Println("error:", err)
}
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
buf := make([]byte, 4)
if _, err := io.ReadFull(r, buf); err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", buf)
// minimal read size bigger than io.Reader stream
longBuf := make([]byte, 64)
if _, err := io.ReadFull(r, longBuf); err != nil {
fmt.Println("error:", err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
if _, err := io.Copy(os.Stdout, s); err != nil {
log.Fatal(err)
}
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
buf := make([]byte, 9)
if _, err := s.Read(buf); err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", buf)
}
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
buf := make([]byte, 6)
if _, err := s.ReadAt(buf, 10); err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", buf)
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
if _, err := s.Seek(10, io.SeekStart); err != nil {
log.Fatal(err)
}
if _, err := io.Copy(os.Stdout, s); err != nil {
log.Fatal(err)
}
}
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
fmt.Println(s.Size())
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
r := strings.NewReader("some io.Reader stream to be read\n")
r.Seek(5, io.SeekStart) // move to the 5th char from the start
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
r.Seek(-5, io.SeekEnd)
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
"strings"
)
func main() {
var r io.Reader = strings.NewReader("some io.Reader stream to be read\n")
r = io.TeeReader(r, os.Stdout)
// Everything read from r will be copied to stdout.
if _, err := io.ReadAll(r); err != nil {
log.Fatal(err)
}
}
package main
import (
"io"
"log"
"os"
)
func main() {
if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
log.Fatal(err)
}
}
Package-Level Type Names (total 27)
/* sort by: | */
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.( ByteReader) ReadByte() (byte, error)ByteScanner(interface)
*bufio.Reader
bufio.ReadWriter
*bytes.Buffer
*bytes.Reader
compress/flate.Reader(interface)
image/jpeg.Reader(interface)
*internal/zstd.Reader
*strings.Reader
func encoding/binary.ReadUvarint(r ByteReader) (uint64, error)
func encoding/binary.ReadVarint(r ByteReader) (int64, error)
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.( ByteScanner) ReadByte() (byte, error)( ByteScanner) UnreadByte() error
*bufio.Reader
bufio.ReadWriter
*bytes.Buffer
*bytes.Reader
*strings.Reader
ByteScanner : ByteReader
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. // max bytes remaining // underlying reader(*LimitedReader) Read(p []byte) (n int, err error)
*LimitedReader : Reader
A PipeReader is the read half of a pipe. Close closes the reader; subsequent writes to the
write half of the pipe will return the error [ErrClosedPipe]. CloseWithError closes the reader; subsequent writes
to the write half of the pipe will return the error err.
CloseWithError never overwrites the previous error if it exists
and always returns nil. Read implements the standard Read interface:
it reads data from the pipe, blocking until a writer
arrives or the write end is closed.
If the write end is closed with an error, that error is
returned as err; otherwise err is EOF.
*PipeReader : Closer
*PipeReader : ReadCloser
*PipeReader : Reader
func Pipe() (*PipeReader, *PipeWriter)
A PipeWriter is the write half of a pipe. Close closes the writer; subsequent reads from the
read half of the pipe will return no bytes and EOF. CloseWithError closes the writer; subsequent reads from the
read half of the pipe will return no bytes and the error err,
or EOF if err is nil.
CloseWithError never overwrites the previous error if it exists
and always returns nil. Write implements the standard Write interface:
it writes data to the pipe, blocking until one or more readers
have consumed all the data or the read end is closed.
If the read end is closed with an error, that err is
returned as err; otherwise err is [ErrClosedPipe].
*PipeWriter : Closer
*PipeWriter : WriteCloser
*PipeWriter : Writer
*PipeWriter : internal/bisect.Writer
func Pipe() (*PipeReader, *PipeWriter)
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.( ReaderAt) ReadAt(p []byte, off int64) (n int, err error)
*SectionReader
*bytes.Reader
debug/elf.Prog
debug/elf.Section
debug/macho.Section
debug/macho.Segment
debug/pe.Section
debug/plan9obj.Section
internal/xcoff.Section
mime/multipart.File(interface)
*os.File
*strings.Reader
func (*SectionReader).Outer() (r ReaderAt, off int64, n int64)
func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
func archive/zip.NewReader(r ReaderAt, size int64) (*zip.Reader, error)
func debug/buildinfo.Read(r ReaderAt) (*buildinfo.BuildInfo, error)
func debug/elf.NewFile(r ReaderAt) (*elf.File, error)
func debug/macho.NewFatFile(r ReaderAt) (*macho.FatFile, error)
func debug/macho.NewFile(r ReaderAt) (*macho.File, error)
func debug/pe.NewFile(r ReaderAt) (*pe.File, error)
func debug/plan9obj.NewFile(r ReaderAt) (*plan9obj.File, error)
func internal/saferio.ReadDataAt(r ReaderAt, n uint64, off int64) ([]byte, error)
func internal/xcoff.NewArchive(r ReaderAt) (*xcoff.Archive, error)
func internal/xcoff.NewFile(r ReaderAt) (*xcoff.File, error)
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.( ReaderFrom) ReadFrom(r Reader) (n int64, err error)
bufio.ReadWriter
*bufio.Writer
*bytes.Buffer
*net.TCPConn
net/http/internal.FlushAfterChunkWriter
*os.File
ReadSeekCloser is the interface that groups the basic Read, Seek and Close
methods.( ReadSeekCloser) Close() error( ReadSeekCloser) Read(p []byte) (n int, err error)( ReadSeekCloser) Seek(offset int64, whence int) (int64, error)
*internal/poll.FD
mime/multipart.File(interface)
net/http.File(interface)
*os.File
ReadSeekCloser : Closer
ReadSeekCloser : ReadCloser
ReadSeekCloser : Reader
ReadSeekCloser : ReadSeeker
ReadSeekCloser : Seeker
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.( RuneScanner) ReadRune() (r rune, size int, err error)( RuneScanner) UnreadRune() error
*bufio.Reader
bufio.ReadWriter
*bytes.Buffer
*bytes.Reader
fmt.ScanState(interface)
*strings.Reader
RuneScanner : RuneReader
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.( Seeker) Seek(offset int64, whence int) (int64, error)
*OffsetWriterReadSeekCloser(interface)ReadSeeker(interface)ReadWriteSeeker(interface)
*SectionReaderWriteSeeker(interface)
*bytes.Reader
*internal/coverage/slicereader.Reader
*internal/coverage/slicewriter.WriteSeeker
*internal/poll.FD
mime/multipart.File(interface)
net/http.File(interface)
*os.File
*strings.Reader
*vendor/golang.org/x/text/unicode/norm.Iter
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.( WriterAt) WriteAt(p []byte, off int64) (n int, err error)
*OffsetWriter
*os.File
func NewOffsetWriter(w WriterAt, off int64) *OffsetWriter
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.( WriterTo) WriteTo(w Writer) (n int64, err error)
*bufio.Reader
bufio.ReadWriter
*bytes.Buffer
*bytes.Reader
*net.Buffers
*net.TCPConn
*os.File
*strings.Reader
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 [WriterTo],
the copy is implemented by calling src.WriteTo(dst).
Otherwise, if dst implements [ReaderFrom],
the copy is implemented by calling dst.ReadFrom(src).
CopyBuffer is identical to Copy except that it stages through the
provided buffer (if one is required) rather than allocating a
temporary one. If buf is nil, one is allocated; otherwise if it has
zero length, CopyBuffer panics.
If either src implements [WriterTo] or dst implements [ReaderFrom],
buf will not be used to perform the copy.
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 [ReaderFrom], the copy is implemented using it.
LimitReader returns a Reader that reads from r
but stops with EOF after n bytes.
The underlying implementation is a *LimitedReader.
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.
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.
NewOffsetWriter returns an [OffsetWriter] that writes to w
starting at offset off.
NewSectionReader returns a [SectionReader] that reads from r
starting at offset off and stops with EOF after n bytes.
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.
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.
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.
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.
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.
Discard is a [Writer] on which all Write calls succeed
without doing anything.
EOF is the error returned by Read when no more input is available.
(Read must return EOF itself, not an error wrapping EOF,
because callers will test for EOF using ==.)
Functions should return EOF only to signal a graceful end of input.
If the EOF occurs unexpectedly in a structured data stream,
the appropriate error is either [ErrUnexpectedEOF] or some other error
giving more detail.
ErrClosedPipe is the error used for read or write operations on a closed pipe.
ErrNoProgress is returned by some clients of a [Reader] when
many calls to Read have failed to return any data or error,
usually the sign of a broken [Reader] implementation.
ErrShortBuffer means that a read required a longer buffer than was provided.
ErrShortWrite means that a write accepted fewer bytes than requested
but failed to return an explicit error.
ErrUnexpectedEOF means that EOF was encountered in the
middle of reading a fixed-size block or data structure.
Package-Level Constants (total 3)
Seek whence values.
Seek whence values.
Seek whence values.
The pages are generated with Goldsv0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.
