io

package
v1.21.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 2, 2023 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

Package io は基本的なI/Oプリミティブに対するインターフェースを提供します。 その主な役割は、パッケージosなどの既存の実装を共有の公開インターフェースにラップすることで、 機能を抽象化し、関連するプリミティブを提供することです。

これらのインターフェースとプリミティブは、低レベルの操作をさまざまな実装でラップするため、 明示的に指示がない限り、クライアントは並行実行には安全ではないと想定すべきではありません。

Index

Examples

Constants

View Source 
const (
	SeekStart   = 0
	SeekCurrent = 1
	SeekEnd     = 2
)

値の発見を求める。

Variables

View Source 
var EOF = errors.New("EOF")

EOFは、入力がもう利用できない場合にReadが返すエラーです。 （EOF自体ではなく、EOFをラップしたエラーを返すのではなく、 EOFをテストするために呼び出し元で==を使用するためです。） 関数は、入力の優雅な終了を示すために、EOFのみを返すべきです。 もしEOFが構造化されたデータストリームで予期しない場所で発生した場合、 適切なエラーはErrUnexpectedEOFまたはその他の詳細を示すエラーです。

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

ErrClosedPipeは、クローズされたパイプに対する読み取りまたは書き込み操作で使用されるエラーです。

View Source 
var ErrNoProgress = errors.New("multiple Read calls return no data or error")

ErrNoProgressは、一部のReaderのクライアントがデータやエラーを返さずに、 複数回のRead呼び出しが失敗した場合に返されます。 通常は、破損したReaderの実装を示しています。

View Source 
var ErrShortBuffer = errors.New("short buffer")

ErrShortBuffer は、読み込みに提供されたバッファよりも長いバッファが必要だったことを意味します。

View Source 
var ErrShortWrite = errors.New("short write")

ErrShortWriteは、要求されたバイト数よりも少ないバイト数の書き込みを受け付けたが、 明示的なエラーを返すことができなかったことを意味します。

View Source 
var ErrUnexpectedEOF = errors.New("unexpected EOF")

ErrUnexpectedEOFは、固定サイズのブロックまたはデータ構造の読み取り途中にEOFが出現したことを意味します。

Functions

func Copy 

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

CopyはsrcからdstにEOFに到達するか、エラーが発生するまでコピーします。コピーされたバイト数と最初に遭遇したエラーが返されます。 成功したコピーではerr == nilを返します。err == EOFではありません。 CopyはsrcからEOFに到達するまで読み取るように定義されているため、ReadからのEOFは報告されるエラーではありません。

srcがWriterToインターフェースを実装している場合、コピーはsrc.WriteTo(dst)の呼び出しで実装されます。 それ以外の場合、dstがReaderFromインターフェースを実装している場合、コピーはdst.ReadFrom(src)の呼び出しで実装されます。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

some io.Reader stream to be read

func CopyBuffer added in v1.5.0 

func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)

CopyBuffer は Copy と同じですが、一時的なバッファを割り当てる代わりに、 提供されたバッファを使用してステージングします（必要な場合）。buf が nil の場合、一時的なバッファが割り当てられます。 もし buf の長さがゼロなら、CopyBuffer はパニックを引き起こします。

もし src が WriterTo を実装しているか、dst が ReaderFrom を実装している場合、 コピーを実行するために buf は使用されません。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

first reader
second reader

func CopyN 

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

CopyNはsrcからdstにnバイト（またはエラーになるまで）をコピーします。 コピーされたバイト数とコピー中に最初に遭遇したエラーが返されます。 コピーが完了し、エラーがない場合、written == nが成り立ちます。

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

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

some

func Pipe 

func 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.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)
	}

}

Output:

some io.Reader stream to be read

func ReadAll added in v1.16.0 

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

ReadAllはrからエラーまたはEOFが発生するまで読み取り、読み取ったデータを返します。 成功した呼び出しではerr == nil、err == EOFではありません。ReadAllはsrcからEOFが発生するまで読み取るように定義されているため、ReadからのEOFはエラーとして報告されません。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)

}

Output:

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の場合、読み取られたバイトがない場合のみです。 minバイト未満の読み取り後にEOFが発生した場合、ReadAtLeastはErrUnexpectedEOFを返します。 minがbufの長さよりも大きい場合、ReadAtLeastはErrShortBufferを返します。 戻り値のn >= min if and only if err == nil。 rが少なくともminバイトを読み取った後にエラーが発生した場合、エラーは破棄されます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)
	}

}

Output:

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

func ReadFull 

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

ReadFullはrからbufにちょうどlen(buf)バイト読み込みます。 読み込まれたバイト数と、読み込まれたバイト数が少なかった場合のエラーが返されます。 エラーは、バイトが一つも読み込まれなかった場合にのみEOFです。 一部のバイトが読み込まれた後にEOFが発生した場合、ReadFullはErrUnexpectedEOFを返します。 返り値では、n == len(buf)であるのはerr == nilの場合のみです。 rが少なくともlen(buf)バイトを読み込んだ後にエラーが発生した場合、そのエラーは無視されます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)
	}

}

Output:

some
error: unexpected EOF

func WriteString 

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

WriteStringはstring sの内容をバイトスライスを受け取るwに書き込みます。 もしwがStringWriterを実装している場合は、WriteStringメソッドが直接呼び出されます。 そうでない場合は、w.Writeが一度だけ呼び出されます。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
)

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

}

Output:

Hello World

Types

type ByteReader 

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

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

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

ReadByteはバイト単位の効率的な処理を提供します。 ByteReaderを実装していないReaderは、bufio.NewReaderを使用してこのメソッドを追加することができます。

type ByteScanner 

type ByteScanner interface {
	ByteReader
	UnreadByte() error
}

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

UnreadByteは、次のReadByte呼び出しで最後に読み込まれたバイトを返します。 最後の操作がReadByteへの成功した呼び出しでない場合、UnreadByteはエラーを返す可能性があります。 最後に読み込まれたバイト（または最後に読み込まれていないバイトの前のバイト）を未読状態に戻すか、 （Seekerインターフェースをサポートする実装の場合）現在のオフセットの1バイト前にシークします。

type ByteWriter added in v1.1.0 

type ByteWriter interface {
	WriteByte(c byte) error
}

ByteWriterはWriteByteメソッドをラップするインターフェースです。

type Closer 

type Closer interface {
	Close() error
}

Closerは基本のCloseメソッドをラップするインターフェースです。

最初の呼び出し後のCloseの振る舞いは未定義です。 特定の実装は独自の振る舞いを文書化することがあります。

type LimitedReader 

type LimitedReader struct {
	R Reader
	N int64
}

LimitedReaderはRから読み込みますが、返されるデータ量をNバイトに制限します。Readの各呼び出しは、新しい残りの量を反映するためにNを更新します。また、N <= 0または基になるRがEOFを返す場合に、ReadはEOFを返します。

func (*LimitedReader) Read 

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

type OffsetWriter added in v1.20.0 

type OffsetWriter struct {
	// contains filtered or unexported fields
}

OffsetWriterは、基準オフセットから基準オフセット+オフセットの範囲で下位のライターへの書き込みをマッピングします。

func NewOffsetWriter added in v1.20.0 

func NewOffsetWriter(w WriterAt, off int64) *OffsetWriter

NewOffsetWriterは、オフセットoffから書き込むOffsetWriterを返します。

func (*OffsetWriter) Seek added in v1.20.0 

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

func (*OffsetWriter) Write added in v1.20.0 

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

func (*OffsetWriter) WriteAt added in v1.20.0 

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

type PipeReader 

type PipeReader struct {
	// contains filtered or unexported fields
}

PipeReaderは、パイプの読み取り側です。

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 

type PipeWriter struct {
	// contains filtered or unexported fields
}

PipeWriterは、パイプの書き込み側です。

func (*PipeWriter) Close 

func (w *PipeWriter) Close() error

Close closes the writer; subsequent reads from the read half of the pipe will return no bytes and EOF.

func (*PipeWriter) CloseWithError 

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

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.

func (*PipeWriter) Write 

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

Writeは、標準のWriteインターフェースを実装します。 データをパイプに書き込み、1つ以上のリーダーがすべてのデータを消費するか、 読み取り側が閉じられるまでブロックします。 読み取り側がエラーで閉じられた場合、そのエラーがerrとして返されます。 それ以外の場合、errはErrClosedPipeです。

type ReadCloser 

type ReadCloser interface {
	Reader
	Closer
}

ReadCloserは基本的なReadとCloseメソッドをまとめるインターフェースです。

func NopCloser added in v1.16.0 

func NopCloser(r Reader) ReadCloser

NopCloser は、提供された Reader r を包む、Close メソッドの動作がない ReadCloser を返します。 r が WriterTo を実装している場合、返された ReadCloser は WriterTo を実装し、 呼び出しを r に転送します。

type ReadSeekCloser added in v1.16.0 

type ReadSeekCloser interface {
	Reader
	Seeker
	Closer
}

ReadSeekCloserは、基本的なRead、Seek、Closeメソッドをグループ化するインターフェースです。

type ReadSeeker 

type ReadSeeker interface {
	Reader
	Seeker
}

ReadSeekerは、基本的なReadとSeekメソッドをグループ化するインターフェースです。

type ReadWriteCloser 

type ReadWriteCloser interface {
	Reader
	Writer
	Closer
}

ReadWriteCloserは、基本的なRead、Write、Closeメソッドをグループ化するインタフェースです。

type ReadWriteSeeker 

type ReadWriteSeeker interface {
	Reader
	Writer
	Seeker
}

ReadWriteSeekerは基本的なRead、Write、Seekメソッドをグループ化するインターフェースです。

type ReadWriter 

type ReadWriter interface {
	Reader
	Writer
}

ReadWriterは基本的なReadとWriteメソッドをグループ化するインターフェースです。

type Reader 

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

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を処理する必要があります。これにより、いくつかのバイトを読んだ後に発生するI/Oエラーや、許可されるEOFの両方の動作が正しく処理されます。 len(p) == 0の場合、Readは常にn == 0を返すべきです。EOFなどのエラー条件が既知の場合、非nilのエラーを返す場合があります。 Readの実装は、len(p) == 0の場合を除き、0バイトカウントとnilエラーを返すことは避けるべきです。呼び出し元は、0とnilの返り値は何も発生しなかったことを示しており、特にEOFを示しているわけではないと扱うべきです。 実装はpを保持してはいけません。

func LimitReader 

func LimitReader(r Reader, n int64) Reader

LimitReaderは、rから読み取るReaderを返します。 しかし、nバイト後にEOFで停止します。 内部の実装は*LimitedReaderです。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

some

func MultiReader 

func MultiReader(readers ...Reader) Reader

MultiReaderは、提供された入力リーダーの論理的な連結であるReaderを返します。 これらは順次読み取られます。すべての入力がEOFを返したら、ReadはEOFを返します。 リーダーのいずれかがnilでない、EOFでないエラーを返す場合、Readはそのエラーを返します。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

first reader second reader third reader

func TeeReader 

func TeeReader(r Reader, w Writer) Reader

TeeReaderは、rから読み取ったものをwに書き込むReaderを返します。 これを通じて実行されるrからの全ての読み取りは、 対応するwへの書き込みとマッチングされます。 内部バッファリングはありません - 読み取りが完了する前に書き込みが完了する必要があります。 書き込み中にエラーが発生した場合、読み取りエラーとして報告されます。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

some io.Reader stream to be read

type ReaderAt 

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

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

ReadAtは、基になる入力ソースのオフセットoffから始まるpにlen(p)バイトを読み込みます。 読み込まれたバイト数(0 <= n <= len(p))と、エラーが発生した場合のエラーを返します。

ReadAtがn < len(p)を返す場合、なぜ追加のバイトが返されなかったかを説明する非nilのエラーが返されます。 この点で、ReadAtはReadよりも厳格です。

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

ReadAtが返すn = len(p)バイトが入力ソースの末尾にある場合、ReadAtはerr == EOFまたはerr == nilのどちらかを返す可能性があります。

ReadAtがシークオフセットを持つ入力ソースから読み込んでいる場合、 ReadAtは基になるシークオフセットに影響を与えないし、影響を受けません。

ReadAtのクライアントは、同じ入力ソースに対して並行してReadAt呼び出しを実行できます。

実装はpを保持してはいけません。

type ReaderFrom 

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

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

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

Copy関数はReaderFromが利用可能な場合に使用します。

type RuneReader 

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

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

ReadRuneは単一のエンコードされたUnicode文字を読み取り、 その文字とバイトサイズを返します。文字が利用できない場合、errが設定されます。

type RuneScanner 

type RuneScanner interface {
	RuneReader
	UnreadRune() error
}

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

UnreadRuneは次のReadRune呼び出しで最後に読み取られたルーンを返します。 もし最後の操作が成功したReadRune呼び出しでない場合、UnreadRuneはエラーを返す、最後に読み取られたルーン（または最後に未読となったルーンの前のルーン）を未読扱いにする、 または（Seekerインターフェースをサポートする実装の場合）現在のオフセットの直前のルーンの先頭にシークする可能性があります。

type SectionReader 

type SectionReader struct {
	// contains filtered or unexported fields
}

SectionReaderは、元となるReaderAtの一部に対してRead、Seek、ReadAtを実装します。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

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)
Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)

}

Output:

io.Reader

func (*SectionReader) ReadAt 

func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)

}

Output:

stream

func (*SectionReader) Seek 

func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/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)
	}

}

Output:

stream

func (*SectionReader) Size 

func (s *SectionReader) Size() int64

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	s := io.NewSectionReader(r, 5, 17)

	fmt.Println(s.Size())

}

Output:

17

type Seeker 

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

Seekerは基本のSeekメソッドをラップするインターフェースです。 Seekは、オフセットを次のReadまたはWriteのために設定します。 whenceに従って解釈されます。 SeekStartはファイルの先頭を基準とします。 SeekCurrentは現在のオフセットを基準とします。 SeekEndは末尾を基準とします。 (例えば、offset = -2はファイルの最後から1つ前のバイトを指定します)。 Seekは、ファイルの先頭を基準とした新たなオフセットまたはエラーを返します。 ファイルの先頭より前のオフセットにシークすることはエラーです。 任意の正のオフセットにシークすることは許可されるかもしれませんが、 新しいオフセットが基になるオブジェクトのサイズを超える場合、 その後のI/O操作の振る舞いは実装に依存します。

type StringWriter added in v1.12.0 

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

StringWriterは、WriteStringメソッドを包んでいるインターフェースです。

type WriteCloser 

type WriteCloser interface {
	Writer
	Closer
}

WriteCloserは基本的なWriteとCloseメソッドをグループ化するインターフェースです。

type WriteSeeker 

type WriteSeeker interface {
	Writer
	Seeker
}

WriteSeekerは基本的なWriteとSeekメソッドをグループ化するインターフェースです。

type Writer 

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

Writerは基本的なWriteメソッドを包むインターフェースです。

Writeはpから基礎となるデータストリームにlen(p)バイトを書き込みます。 それはpから書き込まれたバイト数（0 <= n <= len(p)）と、 書き込みが早期に停止させたエラーを返します。 Writeは、n < len(p)の場合には非nilのエラーを返さなければなりません。 Writeは、スライスデータを一時的にでも変更してはいけません。

実装はpを保持してはいけません。 

var Discard Writer = discard{}

Discardは、何もせずにすべての書き込み呼び出しに成功するWriterです。

func MultiWriter 

func MultiWriter(writers ...Writer) Writer

MultiWriterは、Unixのtee(1)コマンドに似た、書き込みを提供されたすべてのライターに複製するライターを作成します。

各書き込みは、1つずつリストされたすべてのライターに書き込まれます。 リストされたライターのいずれかがエラーを返すと、その全体の書き込み操作が停止し、エラーが返されます。 リストは、書き込み操作が完了するまで変更されるべきではありません。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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())

}

Output:

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

type WriterAt 

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

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

WriteAtはpからlen(p)バイトを下層のデータストリームのoffセットに書き込みます。 書き込まれたバイト数n(0 <= n <= len(p))と書き込みが早期に終了した原因となった エラーが返されます。もしn < len(p)なら、WriteAtは非nilのエラーを返さなければなりません。

もしWriteAtがseekオフセットを持つ宛先に書き込みを行っている場合、 WriteAtは下層のseekオフセットに影響を与えず、また影響を受けてはいけません。

WriteAtのクライアントは、範囲が重ならない場合には同じ宛先で並列して WriteAt呼び出しを実行することができます。

実装はpを保持してはいけません。

type WriterTo 

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

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

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

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

Source Files

View all Source files

Directories

Path Synopsis
Package fsはファイルシステムへの基本的なインターフェースを定義します。
 Package fsはファイルシステムへの基本的なインターフェースを定義します。
パッケージioutilは、いくつかのI/Oユーティリティ関数を実装しています。
 パッケージioutilは、いくつかのI/Oユーティリティ関数を実装しています。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.