...

パッケージ io

概要 ▾

io パッケージは I/O の基本的なインターフェースを提供します。 io パッケージが行うのは,os パッケージの中にあるような実装をラップして,機能を抽象化し, 共通の公開インターフェースを提供することです。

これらのインターフェースは,様々な実装による低レベル操作をラップしているため, 特記されているのでない限り, 並行実行に対して安全であると考えることはできません。

目次 ▾

定数
変数
func Copy(dst Writer, src Reader) (written int64, err error)
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
func Pipe() (*PipeReader, *PipeWriter)
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
func ReadFull(r Reader, buf []byte) (n int, err error)
func WriteString(w Writer, s string) (n int, err error)
type ByteReader
type ByteScanner
type ByteWriter
type Closer
type LimitedReader
    func (l *LimitedReader) Read(p []byte) (n int, err error)
type PipeReader
    func (r *PipeReader) Close() error
    func (r *PipeReader) CloseWithError(err error) error
    func (r *PipeReader) Read(data []byte) (n int, err error)
type PipeWriter
    func (w *PipeWriter) Close() error
    func (w *PipeWriter) CloseWithError(err error) error
    func (w *PipeWriter) Write(data []byte) (n int, err error)
type ReadCloser
type ReadSeeker
type ReadWriteCloser
type ReadWriteSeeker
type ReadWriter
type Reader
    func LimitReader(r Reader, n int64) Reader
    func MultiReader(readers ...Reader) Reader
    func TeeReader(r Reader, w Writer) Reader
type ReaderAt
type ReaderFrom
type RuneReader
type RuneScanner
type SectionReader
    func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
    func (s *SectionReader) Read(p []byte) (n int, err error)
    func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
    func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
    func (s *SectionReader) Size() int64
type Seeker
type StringWriter
type WriteCloser
type WriteSeeker
type Writer
    func MultiWriter(writers ...Writer) Writer
type WriterAt
type WriterTo

パッケージファイル

io.go multi.go pipe.go

定数

Seek の状態

const (
    SeekStart   = 0 // ファイルの起点を基準にシーク
    SeekCurrent = 1 // 現在のオフセットを基準にシーク
    SeekEnd     = 2 // 終わりを起点にシーク
)

変数

EOF は,入力がなくなったときに Read から返されるエラーです。 入力が終わったことを示すためだけに EOF を用いるべきです。 構造を持つデータストリーム中に EOF が予期せず発生した場合の 適切なエラーは ErrUnexpectedEOF かほかのさらに詳細な情報を表すエラーです。

var EOF = errors.New("EOF")

ErrClosedPipe は閉じられたパイプでの読み込み書き込み操作を行おうとした時のエラーです。

var ErrClosedPipe = errors.New("io: read/write on closed pipe")

ErrNoProgress は, Read を何回も呼び出したが,何のデータもエラーも返ってこない ことを表します。 大抵の場合, io.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 で EOF となるかエラーが発生するまで, src から dst にコピーします。コピーされたバイト数と,もしあればコピー中に発生した最初のエラーを返します。

コピーが成功すると, err == EOF ではなく, err == nil が返されます。 Copy は src から EOF まで読み取るように定義されているため, Read からの EOF は報告されるエラーとして扱われません。

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 はパニックします。

コード:

r1 := strings.NewReader("first reader\n")
r2 := strings.NewReader("second reader\n")
buf := make([]byte, 8)

// ここで buf を使っていて,...
if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
    log.Fatal(err)
}

// ... ここでも再利用しています。余分のバッファを割り当てる必要はありません。
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 にコピーします。コピーされたバイト数とコピー中に発生した最初のエラーを返します。 err == nil の場合必ず,またその場合に限り,written == n となります。

dst が ReaderFrom インターフェースを実装している場合,それを使用してコピーされます。

コード:

r := strings.NewReader("some io.Reader stream to be read")

if _, err := io.CopyN(os.Stdout, r, 5); err != nil {
    log.Fatal(err)
}

出力:

some

func Pipe

func Pipe() (*PipeReader, *PipeWriter)

Pipe は,同期インメモリパイプを作成します。 io.Reader を必要とするコードと io.Writer を必要とするコードを結びつけるのに使えます。

パイプ中の Read と Write は,一対一対応となります。 ただし,1 つの Write が複数の Read を必要とする場合は別です。 つまり,PipeWriter への毎回の Write は,書かれたデータをすべて読み込む 1 回かそれ以上の Read があるまでブロックします。

データは Write から 対応する Read に直接コピーされます。 内部にバッファはありません。

並列に,Read と Write を呼び出しても,あるいは Close を呼び出しても安全です。 Read を並列に呼び出す,あるいは Write を並列に呼び出すのも安全です。 それぞれの呼び出しはシーケンシャルに処理されます。

コード:

r, w := io.Pipe()

go func() {
    fmt.Fprint(w, "some text to be read\n")
    w.Close()
}()

buf := new(bytes.Buffer)
buf.ReadFrom(r)
fmt.Print(buf.String())

出力:

some text to be read

func ReadAtLeast

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

ReadAtLeast は,少なくとも min バイトを r から buf に読み込みます。コピーされたバイト数と,読み取られたバイト数が min より少なければエラーを返します。バイトがまったく読み取られなかった場合のみ,エラーは EOF となります。 min バイト未満の読み取りで EOF が発生した場合, ReadAtLeast は ErrUnexpectedEOF を返します。 min が buf の長さより大きい場合, ReadAtLeast は ErrShortBuffer を返します。 err == nil の場合は必ず,またその場合に限り, n >= min となります。 r が min バイト以上読み込んだ後にエラーを返した場合,そのエラーは破棄されます。

コード:

r := strings.NewReader("some io.Reader stream to be read\n")

buf := make([]byte, 33)
if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
    log.Fatal(err)
}
fmt.Printf("%s\n", buf)

// 最小の読み込みサイズよりも小さい buffer
shortBuf := make([]byte, 3)
if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
    fmt.Println("error:", err)
}

// 最小読み込みサイズが io.Reader ストリームよりも大きい
longBuf := make([]byte, 64)
if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
    fmt.Println("error:", err)
}

出力:

some io.Reader stream to be read

error: short buffer
error: EOF

func ReadFull

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

ReadFull は,きっかり len(buf) バイトを r から buf に読み込みます。コピーされたバイト数と,読み取られたバイト数が少なければエラーを返します。バイトがまったく読み取られなかった場合のみ,エラーは EOF となります。すべてのバイトではなく一部のバイトを読み取った後に EOF が発生した場合, ReadFull は ErrUnexpectedEOF を返します。 err == nil の場合は必ず,またその場合に限り, n == len(buf) を返します。 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)

// 最小読み込みサイズが io.Reader ストリームよりも大きい
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 を実装している場合は,その WriteString メソッドが直接呼び出されます。それ以外の場合, w.Write は 1 回だけ呼び出されます。

コード:

io.WriteString(os.Stdout, "Hello World")

出力:

Hello World

type ByteReader

ByteReader は, ReadByte メソッドをラップするインターフェースです。

ReadByte は,入力からの次のバイトまたは発生したエラーを読み込んで返します。 ReadByte がエラーを返した場合,入力バイトは消費されず,返されるバイト値は未定義です。

type ByteReader interface {
    ReadByte() (byte, error)
}

type ByteScanner

ByteScanner は, UnreadByte メソッドを基本の ReadByte メソッドに追加したインターフェースです。

UnreadByte を呼び出すと,次回の ReadByte の呼び出しで,前回の ReadByte の呼び出しと同じバイトを返します。途中で ReadByte を呼び出さずに UnreadByte を 2 回呼び出すとエラーになることがあります。

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 は返されるデータ量をちょうど N バイトに制限して R から読み取ります。 Read を呼び出すたびに残りのバイト数 N が更新されます。 N <= 0 または R が EOF を返すと, Read は EOF を返します。

type LimitedReader struct {
    R Reader // 内部 Reader
    N int64  // 残りの最大バイト数
}

func (*LimitedReader) Read

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

type PipeReader

PipeReader は,パイプの読み込み部分です。

type PipeReader struct {
    // エクスポートされていないフィールドがあります
}

func (*PipeReader) Close

func (r *PipeReader) Close() error

Close はリーダーを閉じます。パイプの書き込み側への以降の書き込みは ErrClosedPipe エラーを返します。

func (*PipeReader) CloseWithError

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

CloseWithError は,reader を閉じます。subsequent writes 以降,パイプの書き込み部分への書き込みはエラー err を返します。

func (*PipeReader) Read

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

Read は,標準の Read インターフェースを実装します: パイプからデータを読み込み, writer が来るあるいは書き込み先が閉じられるまでブロックします。 書き込み先がエラーで閉じられたなら, そのエラーが返されます。それ以外の場合, err はEOF です。

type PipeWriter

PipeWriter はパイプの書き込み部分です。

type PipeWriter struct {
    // エクスポートされていないフィールドがあります
}

func (*PipeWriter) Close

func (w *PipeWriter) Close() error

Close は,writer を閉じます。 以降のパイプの読み込み側の読み込みは,0 バイト と EOF を返します。

func (*PipeWriter) CloseWithError

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

CloseWithError は,writer を閉じます。 以降のパイプの読み込み側の読み込みは,0 バイト と エラー err あるいは err が nil の場合は EOF を返します。

CloseWithError は必ず nil を返します。

func (*PipeWriter) Write

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

Write は標準の Write インターフェースを実装します。 パイプにデータを書き込み,1 つかそれ以上の reader がすべてのデータを取得するか読み込み端末が閉じられるまでブロックします。

読み込み端末がエラーで閉じた場合,そのエラー err として返されます。 それ以外の場合, err は ErrClosedPipe です。

type ReadCloser

ReadCloser は,基本的な Read と Close メソッドを一緒にしたインターフェースです。

type ReadCloser interface {
    Reader
    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 が 0 でないバイト数を読み込んで入力ストリームの終わりに達した場合, err == EOF あるいは err == nil を返します。 次回の Read 呼び出しでは, 0, EOF を返します。

呼び出し元は必ず,エラーを処理する前に n > 0 バイトを処理すべきです。 そうすれば,いくらかのバイトを読み込んだ後に発生する I/O エラーと,Doing so correctly handles I/O errors EOF の振る舞いの両方を正しく処理できます。

0 バイトと nil エラーを返す Read の実装は勧められません。 ただし, 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 は, r から読み取り, n バイト後に EOF で停止する Reader を返します。内部実装は *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 を論理的に結合した Reader です。 シーケンシャルに読み込みます。 すべての入力が EOF を返したとき,Read は EOF を返します。 いずれかの Reader が 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 は, r から読み込んだものを w に書き込む Reader を返します。 r からの読み取りはすべて, w へ書き込まれます。内部バッファリングはありません。読み取りが完了する前に書き込みが完了します。書き込み中に発生したエラーは読み取りエラーとして報告されます。

コード:

r := strings.NewReader("some io.Reader stream to be read\n")
var buf bytes.Buffer
tee := io.TeeReader(r, &buf)

printall := func(r io.Reader) {
    b, err := ioutil.ReadAll(r)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%s", b)
}

printall(tee)
printall(&buf)

出力:

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

type ReaderAt

ReaderAt は,基本的な ReadAt メソッドをラップするインタフェースです。

ReadAt は,内部の入力ソースの位置 off から len(p) バイトを p に読み込みます。読み込んだバイト数 (0 <= n <= len(p)) と発生したエラーを返します。

返り値 n が len(p) より小さい場合,なぜもっと多くのバイトを読み込まなかったのか理由を説明する nil でないエラーを返します。 この点で,ReadAt は Read よりも厳密です。

ReadAt が n < len(p) を返しても,呼び出し中に p 全体を使用することがあります。利用可能なデータがあっても len(p) バイトでない場合,ReadAt はすべてのデータが利用可能になるかエラーが発生するまでブロックします。この点で,ReadAt は Read とは異なります。

入力ソースの末尾で n = len(p) バイトが返る場合,ReadAt は err == EOF または err == nil のいずれかを返します。

ReadAt がシークオフセットを使用して入力ソースから読み取っている場合,ReadAt は内部のシークオフセットに影響を与えたり,影響を受けたりしてはなりません。

ReadAt の呼び出し側は,同じ入力ソースに対して並列に ReadAt 呼び出しを実行できます。

p を保持する実装を書いてはなりません。

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

type ReaderFrom

ReaderFrom は,ReadFrom メソッドをラップするインタフェースです。

ReadFrom は EOF またはエラーが発生するまで r からデータを読み取ります。 戻り値 n は読み取られたバイト数です。 読み込み中に発生した io.EOF 以外のエラーも返されます。

Copy 関数は,利用可能であれば ReaderFrom を使用します。

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

type RuneReader

RuneReader は, ReadRune メソッドをラップするインターフェースです。

ReadRune は UTF-8 エンコードされた Unicode 文字を 1 文字読み取り,ルーンとそのサイズをバイト数で返します。文字がない場合は, err が設定されます。

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

type RuneScanner

RuneScanner は, UnreadRune メソッドを基本の ReadRune メソッドに追加したインターフェイスです。

UnreadRune を呼び出すと,次回の ReadRune の呼び出しで,前回の ReadRune の呼び出しと同じルーンを返します。途中で ReadRune を呼び出さずに UnreadRune を 2 回呼び出すとエラーになることがあります。

type RuneScanner interface {
    RuneReader
    UnreadRune() error
}

type SectionReader

SectionReader は,内部の ReaderAt 上のセクションに Read, Seek, ReadAt を実装します。

type SectionReader struct {
    // エクスポートされていないフィールドがあります
}

コード:

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

func NewSectionReader

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

NewSectionReader は,r のオフセット off の位置から読み取り, n バイト後に EOF で停止する SectionReader を返します。

func (*SectionReader) Read

func (s *SectionReader) Read(p []byte) (n int, err error)

func (*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, 16)

buf := make([]byte, 6)
if _, err := s.ReadAt(buf, 10); err != nil {
    log.Fatal(err)
}

fmt.Printf("%s\n", buf)

出力:

stream

func (*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, 16)

if _, err := s.Seek(10, io.SeekStart); err != nil {
    log.Fatal(err)
}

buf := make([]byte, 6)
if _, err := s.Read(buf); err != nil {
    log.Fatal(err)
}

fmt.Printf("%s\n", buf)

出力:

stream

func (*SectionReader) Size

func (s *SectionReader) Size() int64

Size はセクションのサイズをバイト単位で返します。

type Seeker

Seeker は,基本的な Seek メソッドをラップするインターフェースです。

Seek は,次の Read あるいは Write が始まる位置を offset で指定します。 whence によって,次の位置になります。 SeekStart は,ファイルの最初からの相対位置です。 SeekCurrent は,現在の位置からの相対位置です。 SeekEnd は,最後からの相対位置です。 Seek は,ファイルの最初からの新たな相対位置とエラー(もしあれば)を返します。

ファイルの最初より前の位置への Seek はエラーです。 正の場所への Seek はどれも問題ありませんが,Seek 後の内部オブジェクトへの I/O 操作は実装に依存します。

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

type StringWriter 1.12

StringWriter は, WriteString メソッドをラップするインターフェースです。

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

type WriteCloser

WriteCloser は,基本的な Write と Close メソッドを一緒にしたインターフェースです。

type WriteCloser interface {
    Writer
    Closer
}

type WriteSeeker

WriteSeeker は,基本的な Write と Seek メソッドを一緒にしたインターフェースです。

type WriteSeeker interface {
    Writer
    Seeker
}

type Writer

Writer は,基本的な Write メソッドをラップするインターフェースです。

Write は,p から len(p) バイトを内部のデータストリームに書き出します。 p から書き出されたバイト数 (0 <= n <= len(p)) と, 書き出しを途中で停止させたエラーがあればそのエラーを返します。 Write は n < len(p) ならば,nil でないエラーを返さなければなりません。 Write は,一時的であっても,スライスデータを書き換えてはなりません。

また,実装は p を保持してはなりません。

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

func MultiWriter

func MultiWriter(writers ...Writer) Writer

MultiWriter は,書き込みをすべてのライターに書き込みます。 Unix tee(1) コマンドと似ています。

それぞれの書き込みに対して一つずつライターに書き込みます。 ひとつのライターからエラーが返ってくるなら,全体の操作が止まり, そのエラーを返します。残りのライターに書き込むことはありません。

コード:

r := strings.NewReader("some io.Reader stream to be read\n")

var buf1, buf2 bytes.Buffer
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

type WriterAt

WriterAt は基本的な WriteAt メソッドをラップするインターフェースです。

WriteAt は, オフセット off の位置で, p から len(p) バイトを内部データストリームに書き込みます。 p から書き込まれたバイト数 (0 <= n <= len(p)) と,書き込みを早期に停止させる原因となったエラーが返されます。 WriteAt が n < len(p) を返す場合, nil 以外のエラーを返さなければなりません。

WriteAt がシークオフセットを使用して書き込みを行っている場合, WriteAt は内部のシークオフセットに影響を与えたり,影響を受けたりしてはなりません。

範囲が重ならない場合, WriteAt の呼び出し側は同じ書き込み先に並列に WriteAt 呼び出しを実行できます。

p を保持する実装を書いてはなりません。

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

type WriterTo

WriterTo は,WriteTo メソッドをラップするインターフェースです。

WriteTo は,書き込むデータがなくなるまで,またはエラーが発生するまで,データを w に書き込みます。 戻り値 n は書き込まれたバイト数です。 書き込み中に発生したエラーも返されます。

Copy 関数は,利用可能であれば WriterTo を使用します。

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

サブディレクトリ

名前 概要
..
ioutil ioutil パッケージは I/O に役立つ関数を提供します。