Пакет io
Обзор
Пакет io предоставляет базовые интерфейсы для операций ввода-вывода. Его основная задача — обернуть существующие реализации таких примитивов, например, из пакета os, в общие публичные интерфейсы, которые абстрагируют функциональность, а также некоторые другие связанные примитивы.
Поскольку эти интерфейсы и примитивы оборачивают операции более низкого уровня с различными реализациями, клиенты не должны предполагать, что они безопасны для параллельного выполнения, если нет иных указаний.
Индекс
Примеры
Файлы пакета
io.go multi.go pipe.go
Константы
Значения Seek whence.
const (
SeekStart = 0 // seek relative to the origin of the file
SeekCurrent = 1 // seek relative to the current offset
SeekEnd = 2 // seek relative to the end
) Переменные
EOF — это ошибка, возвращаемая Read, когда больше ввода недоступно. (Read должен возвращать сам EOF, а не ошибку, обертывающую EOF, потому что вызывающие стороны будут проверять EOF на равенство.) Функции должны возвращать EOF только для сигнализации о плавном завершении ввода. Если EOF возникает неожиданно в структурированном потоке данных, соответствующей ошибкой является ErrUnexpectedEOF или какая-либо другая ошибка, дающая больше подробностей.
var EOF = errors.New("EOF") ErrClosedPipe — это ошибка, используемая для операций чтения или записи в закрытой трубе.
var ErrClosedPipe = errors.New("io: read/write on closed pipe") ErrNoProgress возвращается некоторыми клиентами Reader, когда многочисленные вызовы Read не вернули никаких данных или ошибок, обычно признак поломки реализации Reader.
var ErrNoProgress = errors.New("multiple Read calls return no data or error") ErrShortBuffer означает, что для чтения потребовался буфер большего размера, чем предоставленный.
var ErrShortBuffer = errors.New("short buffer") ErrShortWrite означает, что запись приняла меньше байтов, чем запрошено, но не вернула явную ошибку.
var ErrShortWrite = errors.New("short write") ErrUnexpectedEOF означает, что EOF был обнаружен в середине чтения блока фиксированного размера или структуры данных.
var ErrUnexpectedEOF = errors.New("unexpected EOF") func Copy
func Copy(dst Writer, src Reader) (written int64, err error)
Copy копирует данные из src в dst до тех пор, пока не будет достигнут конец файла (EOF) в src или не произойдёт ошибка. Возвращает количество скопированных байтов и первую возникшую ошибку, если таковая имеется.
Успешный Copy возвращает err == nil, а не err == EOF. Поскольку Copy определён для чтения из src до EOF, он не обрабатывает EOF от Read как ошибку для отчёта.
Если src реализует WriterTo, копирование реализуется вызовом src.WriteTo(dst). В противном случае, если dst реализует ReaderFrom, копирование реализуется вызовом dst.ReadFrom(src).
Пример
Код:
r := strings.NewReader("some io.Reader stream to be read\n")
if _, err := io.Copy(os.Stdout, r); err != nil {
log.Fatal(err)
}
Вывод:
some io.Reader stream to be read
func CopyBuffer 1.5
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
CopyBuffer идентичен Copy, за исключением того, что он использует предоставленный буфер (если он необходим), а не выделяет временный. Если buf равен nil, выделяется один; в противном случае, если его длина равна нулю, CopyBuffer генерирует ошибку.
Если либо src реализует WriterTo, либо dst реализует ReaderFrom, buf не будет использован для копирования.
Пример
Код:
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)
}
Вывод:
first reader second reader
func CopyN
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
CopyN копирует n байтов (или до возникновения ошибки) из src в dst. Возвращает количество скопированных байтов и самую раннюю встреченную ошибку во время копирования. При возврате written == n тогда и только тогда, когда err == nil.
Если dst реализует ReaderFrom, копирование реализуется с его использованием.
Пример
Код:
r := strings.NewReader("some io.Reader stream to be read")
if _, err := io.CopyN(os.Stdout, r, 4); err != nil {
log.Fatal(err)
}
Вывод:
some
func Pipe
func Pipe() (*PipeReader, *PipeWriter)
Pipe создаёт синхронную внутреннюю трубу в памяти. Она может использоваться для соединения кода, ожидающего io.Reader, с кодом, ожидающим io.Writer.
Чтения и записи в трубе соответствуют друг другу, за исключением случаев, когда для потребления одной записи требуется несколько чтений. То есть каждая запись в PipeWriter блокируется до тех пор, пока она не удовлетворит одно или несколько чтений из PipeReader, которые полностью потребляют записанные данные. Данные копируются напрямую из записи в соответствующее чтение (или чтения); внутреннего буферирования нет.
Безопасно вызывать Read и Write параллельно друг с другом или с Close. Параллельные вызовы Read и параллельные вызовы Write также безопасны: отдельные вызовы будут регулироваться последовательно.
Пример
Код:
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)
}
Вывод:
some io.Reader stream to be read
func ReadAll 1.16
func ReadAll(r Reader) ([]byte, error)
ReadAll считывает из r до ошибки или EOF и возвращает прочитанные данные. Успешный вызов возвращает err == nil, а не err == EOF. Поскольку ReadAll определён для чтения из src до EOF, он не обрабатывает EOF от Read как ошибку для отчёта.
Пример
Код:
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)
Вывод:
Go is a general-purpose language designed with systems programming in mind.
func ReadAtLeast
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
ReadAtLeast считывает из r в buf до тех пор, пока не прочитает как минимум min байт. Он возвращает количество скопированных байтов и ошибку, если прочитано меньше байтов. Ошибка — EOF только если не было прочитано ни одного байта. Если EOF произошел после чтения меньше чем min байтов, ReadAtLeast возвращает ErrUnexpectedEOF. Если min больше длины buf, ReadAtLeast возвращает ErrShortBuffer. При возврате n >= min тогда и только тогда, когда err == nil. Если r возвращает ошибку после прочтения как минимум min байтов, ошибка игнорируется.
Пример
Код:
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)
}
Вывод:
some io.Reader error: short buffer error: unexpected EOF
func ReadFull
func ReadFull(r Reader, buf []byte) (n int, err error)
ReadFull считывает ровно len(buf) байтов из r в buf. Он возвращает количество скопированных байтов и ошибку, если прочитано меньше байтов. Ошибка — EOF только если не было прочитано ни одного байта. Если EOF произошел после чтения некоторых, но не всех байтов, ReadFull возвращает ErrUnexpectedEOF. При возврате n == len(buf) тогда и только тогда, когда err == nil. Если r возвращает ошибку после прочтения как минимум len(buf) байтов, ошибка игнорируется.
Пример
Код:
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)
}
Вывод:
some error: unexpected EOF
func WriteString
func WriteString(w Writer, s string) (n int, err error)
WriteString записывает содержимое строки s в w, который принимает срез байтов. Если w реализует StringWriter, [StringWriter.WriteString] вызывается напрямую. В противном случае, [Writer.Write] вызывается ровно один раз.
Пример
Код:
if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
log.Fatal(err)
}
Вывод:
Hello World
type ByteReader
ByteReader — интерфейс, который оборачивает метод ReadByte.
ReadByte считывает и возвращает следующий байт из входных данных или любую возникшую ошибку. Если ReadByte возвращает ошибку, ни один байт ввода не был извлечен, а возвращаемое значение байта не определено.
ReadByte предоставляет эффективный интерфейс для обработки байтов по одному. Reader, который не реализует ByteReader, можно обернуть с помощью bufio.NewReader, чтобы добавить этот метод.
type ByteReader interface {
ReadByte() (byte, error)
} type ByteScanner
ByteScanner — интерфейс, добавляющий метод UnreadByte к основному методу ReadByte.
UnreadByte приводит к тому, что следующий вызов ReadByte вернёт последний прочитанный байт. Если последняя операция не была успешным вызовом ReadByte, UnreadByte может вернуть ошибку, не прочитать последний прочитанный байт (или байт перед последним непрочитанным байтом) или (в реализациях, поддерживающих интерфейс Seeker) перейти на одну позицию назад относительно текущего смещения.
type ByteScanner interface {
ByteReader
UnreadByte() error
} type ByteWriter 1.1
ByteWriter — интерфейс, который оборачивает метод WriteByte.
type ByteWriter interface {
WriteByte(c byte) error
} type Closer
Closer — интерфейс, который оборачивает базовый метод Close.
Поведение Close после первого вызова не определено. Конкретные реализации могут документировать собственное поведение.
type Closer interface {
Close() error
} type LimitedReader
LimitedReader считывает данные из R, но ограничивает количество возвращаемых данных до N байтов. Каждый вызов Read обновляет N, отражая новое оставшееся количество. Read возвращает EOF, когда N <= 0 или когда базовый R возвращает EOF.
type LimitedReader struct {
R Reader // underlying reader
N int64 // max bytes remaining
}
func (*LimitedReader) Read
func (l *LimitedReader) Read(p []byte) (n int, err error)
type OffsetWriter 1.20
OffsetWriter сопоставляет записи по смещению base со смещением base+off в базовом writer.
type OffsetWriter struct {
// contains filtered or unexported fields
}
func NewOffsetWriter 1.20
func NewOffsetWriter(w WriterAt, off int64) *OffsetWriter
NewOffsetWriter возвращает OffsetWriter, который записывает в w, начиная со смещения off.
func (*OffsetWriter) Seek 1.20
func (o *OffsetWriter) Seek(offset int64, whence int) (int64, error)
func (*OffsetWriter) Write 1.20
func (o *OffsetWriter) Write(p []byte) (n int, err error)
func (*OffsetWriter) WriteAt 1.20
func (o *OffsetWriter) WriteAt(p []byte, off int64) (n int, err error)
type PipeReader
PipeReader — это часть чтения канала.
type PipeReader struct {
// contains filtered or unexported fields
}
func (*PipeReader) Close
func (r *PipeReader) Close() error
Close закрывает чтение; последующие записи в часть записи канала будут возвращать ошибку ErrClosedPipe.
func (*PipeReader) CloseWithError
func (r *PipeReader) CloseWithError(err error) error
CloseWithError закрывает чтение; последующие записи в часть записи канала будут возвращать ошибку err.
CloseWithError никогда не перезаписывает предыдущую ошибку, если она существует, и всегда возвращает nil.
func (*PipeReader) Read
func (r *PipeReader) Read(data []byte) (n int, err error)
Read реализует стандартный интерфейс Read: считывает данные из канала, блокируясь до тех пор, пока не придёт писатель или не будет закрыт конец записи. Если конец записи закрыт с ошибкой, эта ошибка возвращается как err; в противном случае err — EOF.
type PipeWriter
PipeWriter — это часть записи канала.
type PipeWriter struct {
// contains filtered or unexported fields
}
func (*PipeWriter) Close
func (w *PipeWriter) Close() error
Close закрывает запись; последующие чтения из части чтения канала не вернут байтов и вернут EOF.
func (*PipeWriter) CloseWithError
func (w *PipeWriter) CloseWithError(err error) error
CloseWithError закрывает запись; последующие чтения из части чтения канала не вернут байтов и вернут ошибку err, или EOF, если err — nil.
CloseWithError никогда не перезаписывает предыдущую ошибку, если она существует, и всегда возвращает nil.
func (*PipeWriter) Write
func (w *PipeWriter) Write(data []byte) (n int, err error)
Write реализует стандартный интерфейс Write: записывает данные в канал, блокируясь до тех пор, пока один или несколько читателей не потребят все данные или не будет закрыт конец чтения. Если конец чтения закрыт с ошибкой, эта ошибка возвращается как err; в противном случае err — ErrClosedPipe.
type ReadCloser
ReadCloser — интерфейс, объединяющий базовые методы Read и Close.
type ReadCloser interface {
Reader
Closer
} func NopCloser 1.16
func NopCloser(r Reader) ReadCloser
NopCloser возвращает ReadCloser с методом Close без действий, обертывающий предоставленный Reader r. Если r реализует WriterTo, возвращаемый ReadCloser будет реализовывать WriterTo, передавая вызовы r.
type ReadSeekCloser 1.16
ReadSeekCloser — интерфейс, объединяющий базовые методы Read, Seek и Close.
type ReadSeekCloser interface {
Reader
Seeker
Closer
} type ReadSeeker
ReadSeeker — интерфейс, объединяющий базовые методы Read и Seek.
type ReadSeeker interface {
Reader
Seeker
} type ReadWriteCloser
ReadWriteCloser — интерфейс, объединяющий базовые методы Read, Write и Close.
type ReadWriteCloser interface {
Reader
Writer
Closer
} type ReadWriteSeeker
ReadWriteSeeker — интерфейс, объединяющий базовые методы Read, Write и Seek.
type ReadWriteSeeker interface {
Reader
Writer
Seeker
} type ReadWriter
ReadWriter — интерфейс, объединяющий базовые методы Read и Write.
type ReadWriter interface {
Reader
Writer
} type Reader
Reader — интерфейс, который оборачивает базовый метод Read.
Read считывает до len(p) байтов в p. Он возвращает количество прочитанных байтов (0 <= n <= len(p)) и любую возникшую ошибку. Даже если Read возвращает n < len(p), он может использовать весь p в качестве рабочей области во время вызова. Если доступны данные, но не len(p) байтов, Read обычно возвращает доступные данные вместо ожидания дополнительных данных.
Когда Read сталкивается с ошибкой или концом файла после успешного чтения n > 0 байтов, он возвращает количество прочитанных байтов. Он может вернуть (не-nil) ошибку от того же вызова или вернуть ошибку (и n == 0) от последующего вызова. Примером этого общего случая является то, что Reader, возвращающий ненулевое количество байтов в конце входного потока, может вернуть либо err == EOF, либо err == nil. Следующий Read должен вернуть 0, EOF.
Вызывающие стороны должны всегда обрабатывать n > 0 байтов, возвращённых перед рассмотрением ошибки err. Это правильно обрабатывает ошибки ввода-вывода, которые происходят после чтения некоторых байтов, а также оба разрешённых поведения EOF.
Если len(p) == 0, Read всегда должен вернуть n == 0. Он может вернуть не-nil ошибку, если известна какая-либо ошибка, такая как EOF.
Реализации Read не должны возвращать количество байтов 0 с nil ошибкой, за исключением случая len(p) == 0. Вызывающие стороны должны рассматривать возвращение 0 и nil как указание на то, что ничего не произошло; в частности, это не указывает на EOF.
Реализации не должны сохранять p.
type Reader interface {
Read(p []byte) (n int, err error)
} func LimitReader
func LimitReader(r Reader, n int64) Reader
LimitReader возвращает Reader, который считывает из r, но останавливается с EOF после n байтов. Базовая реализация — *LimitedReader.
Пример
Код:
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)
}
Вывод:
some
func MultiReader
func MultiReader(readers ...Reader) Reader
MultiReader возвращает Reader, который является логическим объединением предоставленных читателей входных данных. Они считываются последовательно. После того, как все входы вернули EOF, Read вернёт EOF. Если любой из читателей вернёт не-nil, не-EOF ошибку, Read вернёт эту ошибку.
Пример
Код:
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)
}
Вывод:
first reader second reader third reader
func TeeReader
func TeeReader(r Reader, w Writer) Reader
TeeReader возвращает Reader, который записывает в w то, что считывает из r. Все чтения из r, выполненные через него, соответствуют соответствующим записям в w. Внутреннего буферизации нет — запись должна быть завершена перед завершением чтения. Любая ошибка, возникшая при записи, сообщается как ошибка чтения.
Пример
Код:
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)
}
Вывод:
some io.Reader stream to be read
type ReaderAt
ReaderAt — интерфейс, который оборачивает базовый метод ReadAt.
ReadAt считывает len(p) байтов в p, начиная со смещения off в базовом источнике ввода. Возвращает количество прочитанных байтов (0 <= n <= len(p)) и любую возникшую ошибку.
Когда ReadAt возвращает n < len(p), он возвращает не-nil ошибку, объясняющую, почему не были возвращены дополнительные байты. В этом отношении ReadAt более строг, чем Read.
Даже если ReadAt возвращает n < len(p), он может использовать весь p в качестве рабочей области во время вызова. Если доступны данные, но не len(p) байтов, ReadAt блокируется до тех пор, пока не станут доступны все данные или не произойдёт ошибка. В этом отношении ReadAt отличается от Read.
Если n = len(p) байтов, возвращённых ReadAt, находятся в конце источника ввода, ReadAt может вернуть либо err == EOF, либо err == nil.
END_OF_DOCUMENT_MARKERЕсли ReadAt считывает данные из источника ввода с смещением поиска, ReadAt не должен влиять и не должен быть затронут смещением поиска в базовом источнике.
Клиенты ReadAt могут выполнять параллельные вызовы ReadAt к одному и тому же источнику ввода.
Реализации не должны сохранять p.
type ReaderAt interface {
ReadAt(p []byte, off int64) (n int, err error)
} тип ReaderFrom
ReaderFrom — это интерфейс, который оборачивает метод ReadFrom.
ReadFrom считывает данные из r до достижения EOF или ошибки. Возвращаемое значение n — количество считанных байтов. Любая ошибка, кроме EOF, возникшая во время чтения, также возвращается.
Функция Copy использует ReaderFrom, если он доступен.
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
} тип RuneReader
RuneReader — это интерфейс, который оборачивает метод ReadRune.
ReadRune считывает один кодированный символ Unicode и возвращает руну и ее размер в байтах. Если символ недоступен, err будет установлено.
type RuneReader interface {
ReadRune() (r rune, size int, err error)
} тип RuneScanner
RuneScanner — это интерфейс, который добавляет метод UnreadRune к базовому методу ReadRune.
UnreadRune заставляет следующий вызов ReadRune вернуть последнюю прочитанную руну. Если последняя операция не была успешным вызовом ReadRune, UnreadRune может вернуть ошибку, «непрочитать» последнюю прочитанную руну (или руну перед последней непрочитанной руной) или (в реализациях, поддерживающих интерфейс Seeker) переместить указатель в начало руны перед текущим смещением.
type RuneScanner interface {
RuneReader
UnreadRune() error
} тип SectionReader
SectionReader реализует Read, Seek и ReadAt для части базового ReaderAt.
type SectionReader struct {
// contains filtered or unexported fields
}
Пример
Код:
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)
}
Вывод:
io.Reader stream
функция NewSectionReader
func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
NewSectionReader возвращает SectionReader, который считывает из r, начиная с смещения off и заканчивая EOF после n байтов.
функция (*SectionReader) Outer 1.22
func (s *SectionReader) Outer() (r ReaderAt, off int64, n int64)
Outer возвращает базовый ReaderAt и смещения для части.
Возвращаемые значения совпадают с теми, что были переданы в NewSectionReader при создании SectionReader.
функция (*SectionReader) Read
func (s *SectionReader) Read(p []byte) (n int, err error)
Пример
Код:
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)
Вывод:
io.Reader
функция (*SectionReader) ReadAt
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
Пример
Код:
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)
Вывод:
stream
функция (*SectionReader) Seek
func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
Пример
Код:
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)
}
Вывод:
stream
функция (*SectionReader) Size
func (s *SectionReader) Size() int64
Size возвращает размер части в байтах.
Пример
Код:
r := strings.NewReader("some io.Reader stream to be read\n")
s := io.NewSectionReader(r, 5, 17)
fmt.Println(s.Size())
Вывод:
17
тип Seeker
Seeker — это интерфейс, который оборачивает базовый метод Seek.
Seek устанавливает смещение для следующего Read или Write в offset, интерпретируемое в зависимости от whence: SeekStart означает относительно начала файла, SeekCurrent — относительно текущего смещения, а SeekEnd — относительно конца (например, offset = -2 указывает на предпоследний байт файла). Seek возвращает новое смещение относительно начала файла или ошибку, если она возникла.
Поиск смещения до начала файла — это ошибка. Поиск по любому положительному смещению может быть разрешен, но если новое смещение превышает размер базового объекта, поведение последующих операций ввода-вывода зависит от реализации.
type Seeker interface {
Seek(offset int64, whence int) (int64, error)
} тип StringWriter 1.12
StringWriter — это интерфейс, который оборачивает метод WriteString.
type StringWriter interface {
WriteString(s string) (n int, err error)
} тип WriteCloser
WriteCloser — это интерфейс, который объединяет базовые методы Write и Close.
type WriteCloser interface {
Writer
Closer
} тип WriteSeeker
WriteSeeker — это интерфейс, который объединяет базовые методы Write и Seek.
type WriteSeeker interface {
Writer
Seeker
} тип Writer
Writer — это интерфейс, который оборачивает базовый метод Write.
Write записывает len(p) байтов из p в базовый поток данных. Он возвращает количество записанных байтов из p (0 ≤ n ≤ len(p)) и любую ошибку, возникшую, которая привела к преждевременному завершению записи. Write должен возвращать ненулевую ошибку, если возвращает n < len(p). Write не должен изменять данные среза, даже временно.
Реализации не должны сохранять p.
type Writer interface {
Write(p []byte) (n int, err error)
} Discard — это Writer, для которого все вызовы Write завершаются успешно, не выполняя никаких действий.
var Discard Writer = discard{} функция MultiWriter
func MultiWriter(writers ...Writer) Writer
MultiWriter создает писатель, который дублирует свои записи во все предоставленные писатели, аналогично команде Unix tee(1).
Каждая запись записывается в каждый указанный писатель по одному. Если указанный писатель возвращает ошибку, вся операция записи прекращается и возвращает ошибку; она не продолжает перебирать список.
Пример
Код:
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())
Вывод:
some io.Reader stream to be read some io.Reader stream to be read
тип WriterAt
WriterAt — это интерфейс, который оборачивает базовый метод WriteAt.
WriteAt записывает len(p) байтов из p в базовый поток данных по смещению off. Он возвращает количество записанных байтов из p (0 ≤ n ≤ len(p)) и любую ошибку, возникшую, которая привела к преждевременному завершению записи. WriteAt должен возвращать ненулевую ошибку, если возвращает n < len(p).
Если WriteAt записывает в пункт назначения со смещением поиска, WriteAt не должен влиять и не должен быть затронут смещением поиска в базовом пункте назначения.
Клиенты WriteAt могут выполнять параллельные вызовы WriteAt в том же пункте назначения, если диапазоны не перекрываются.
Реализации не должны сохранять p.
type WriterAt interface {
WriteAt(p []byte, off int64) (n int, err error)
} тип WriterTo
WriterTo — это интерфейс, который оборачивает метод WriteTo.
WriteTo записывает данные в w, пока не закончатся данные или не произойдет ошибка. Возвращаемое значение n — количество записанных байтов. Любая ошибка, возникшая во время записи, также возвращается.
Функция Copy использует WriterTo, если он доступен.
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
} Подкаталоги
| Имя | Описание |
|---|---|
| .. | |
| fs | Пакет fs определяет базовые интерфейсы к файловой системе. |
| ioutil | Пакет ioutil реализует некоторые вспомогательные функции ввода-вывода. |
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/io/
