GoLang io

https://pkg.go.dev/io

常量

io 包中，只定义了三个常量，作为Seek 方法的 whence 参数的值，用于文件或其他可定位数据流的 寻址 操作。

// Seek whence values.
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
)

io.Seeker 接口

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

Seek 方法用于设置下一次读写操作的偏移量

func (o *OffsetWriter) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	default:
		return 0, errWhence
	case SeekStart:
		offset += o.base
	case SeekCurrent:
		offset += o.off
	}
	if offset < o.base {
		return 0, errOffset
	}
	o.off = offset
	return offset - o.base, nil
}

SeekStart

从数据流起始位置开始计算偏移量

SeekCurrent

从数据流当前读写位置开始计算偏移量 SeekCurrent = 1 // seek relative t

SeekEnd

从数据流的末尾开始计算偏移量

变量

EOF

EOF 是当没有更多输入可用时 Read 返回的错误。 函数应当仅在表示输入正常结束时返回 EOF。

// 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.
var EOF = errors.New("EOF")

ErrClosedPipe

ErrClosedPipe 用于对已关闭管道进行读写操作时返回的错误。

// ErrClosedPipe is the error used for read or write operations on a closed pipe.
var ErrClosedPipe = errors.New("io: read/write on closed pipe")

ErrNoProgress

当 Reader 客户端多次调用 Read 方法都未能返回数据或错误时，会返回 ErrNoProgress

// 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.
var ErrNoProgress = errors.New("multiple Read calls return no data or error")

ErrShortBuffer

ErrShortBuffer 表示读取操作所需要的缓冲区长度超过了提供的缓冲区的大小。

// ErrShortBuffer means that a read required a longer buffer than was provided.
var ErrShortBuffer = errors.New("short buffer")

// 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.
// 
// 从 r 读取到 buf 中，读取 min 个 byte 
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
	if len(buf) < min {
		return 0, ErrShortBuffer
	}
	for n < min && err == nil {
		var nn int
		nn, err = r.Read(buf[n:])
		n += nn
	}
	if n >= min {
		err = nil
	} else if n > 0 && err == EOF {
		err = ErrUnexpectedEOF
	}
	return
}

ErrShortWrite

表示写入操作接收的字节数小于请求数量，但未能返回明确的错误信息。具体就是：Writer方法返回的 n 小于传递进去的 []byte 的长度

// ErrShortWrite means that a write accepted fewer bytes than requested
// but failed to return an explicit error.
var ErrShortWrite = errors.New("short write")

bufio.Flush() 方法

// Flush writes any buffered data to the underlying [io.Writer].
func (b *Writer) Flush() error {
	if b.err != nil {
		return b.err
	}
	if b.n == 0 {
		return nil
	}
	n, err := b.wr.Write(b.buf[0:b.n])
	if n < b.n && err == nil {
		// Write 少写了数据，但是又没有给出具体的 error 信息
		err = io.ErrShortWrite
	}
	if err != nil {
		if n > 0 && n < b.n {
			copy(b.buf[0:b.n-n], b.buf[n:b.n])
		}
		b.n -= n
		b.err = err
		return err
	}
	b.n = 0
	return nil
}

ErrUnexpectedEOF

表示在读取固定大小的数据块或数据结构时意外遇到了文件结束符。

// ErrUnexpectedEOF means that EOF was encountered in the
// middle of reading a fixed-size block or data structure.
// 在读取固定大小的块或数据结构时遇到了 EOF
var ErrUnexpectedEOF = errors.New("unexpected EOF")