Black Lives Matter. Support the Equal Justice Initiative.

Package bufio

import "bufio"
Overview
Index
Examples

Overview ▾

包bufio实现了缓冲的I / O. 它包装了一个io.Reader或io.Writer对象,创建了另一个对象(Reader或Writer),该对象也实现了该接口,但提供了缓冲和一些文本I / O帮助.

Index ▾

Constants
Variables
func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)
func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)
func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)
func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)
type ReadWriter
    func NewReadWriter(r *Reader, w *Writer) *ReadWriter
type Reader
    func NewReader(rd io.Reader) *Reader
    func NewReaderSize(rd io.Reader, size int) *Reader
    func (b *Reader) Buffered() int
    func (b *Reader) Discard(n int) (discarded int, err error)
    func (b *Reader) Peek(n int) ([]byte, error)
    func (b *Reader) Read(p []byte) (n int, err error)
    func (b *Reader) ReadByte() (byte, error)
    func (b *Reader) ReadBytes(delim byte) ([]byte, error)
    func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
    func (b *Reader) ReadRune() (r rune, size int, err error)
    func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
    func (b *Reader) ReadString(delim byte) (string, error)
    func (b *Reader) Reset(r io.Reader)
    func (b *Reader) Size() int
    func (b *Reader) UnreadByte() error
    func (b *Reader) UnreadRune() error
    func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
type Scanner
    func NewScanner(r io.Reader) *Scanner
    func (s *Scanner) Buffer(buf []byte, max int)
    func (s *Scanner) Bytes() []byte
    func (s *Scanner) Err() error
    func (s *Scanner) Scan() bool
    func (s *Scanner) Split(split SplitFunc)
    func (s *Scanner) Text() string
type SplitFunc
type Writer
    func NewWriter(w io.Writer) *Writer
    func NewWriterSize(w io.Writer, size int) *Writer
    func (b *Writer) Available() int
    func (b *Writer) Buffered() int
    func (b *Writer) Flush() error
    func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
    func (b *Writer) Reset(w io.Writer)
    func (b *Writer) Size() int
    func (b *Writer) Write(p []byte) (nn int, err error)
    func (b *Writer) WriteByte(c byte) error
    func (b *Writer) WriteRune(r rune) (size int, err error)
    func (b *Writer) WriteString(s string) (int, error)

Package files

bufio.go scan.go

Constants

const (
    // MaxScanTokenSize is the maximum size used to buffer a token
    // unless the user provides an explicit buffer with Scanner.Buffer.
    // The actual maximum token size may be smaller as the buffer
    // may need to include, for instance, a newline.
    MaxScanTokenSize = 64 * 1024
)

Variables

var (
    ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
    ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
    ErrBufferFull        = errors.New("bufio: buffer full")
    ErrNegativeCount     = errors.New("bufio: negative count")
)

扫描仪返回的错误.

var (
    ErrTooLong         = errors.New("bufio.Scanner: token too long")
    ErrNegativeAdvance = errors.New("bufio.Scanner: SplitFunc returns negative advance count")
    ErrAdvanceTooFar   = errors.New("bufio.Scanner: SplitFunc returns advance count beyond input")
)

ErrFinalToken是一个特殊的哨兵错误值. 它打算由Split函数返回,以指示带有错误的传递的令牌是最后一个令牌,在此之后应该停止扫描. 扫描收到ErrFinalToken后,扫描将停止且没有错误. 该值对于尽早停止处理或在有必要交付最终空令牌时很有用. 可以通过自定义错误值实现相同的行为,但在此处提供一个更整洁的方法. 有关此值的用法,请参见emptyFinalToken示例.

var ErrFinalToken = errors.New("final token")

func ScanBytes 1.1

func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)

ScanBytes是扫描程序的拆分功能,它返回每个字节作为令牌.

func ScanLines 1.1

func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)

ScanLines是Scanner的拆分功能,它返回每行文本,并删除所有行尾标记. 返回的行可能为空. 行尾标记是一个可选的回车符,后跟一个强制换行符. 在正则表达式中,它是`\ r?\ n`. 即使没有换行符,也将返回输入的最后一个非空行.

func ScanRunes 1.1

func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)

ScanRunes是扫描程序的拆分功能,它会将每个UTF-8编码的符文作为令牌返回. 返回的符文序列与输入中的范围循环中的字符串序列相同,这意味着错误的UTF-8编码转换为U + FFFD =" \ xef \ xbf \ xbd". 由于具有扫描界面,因此客户端无法将正确编码的替换符文与编码错误区分开.

func ScanWords 1.1

func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)

ScanWords是扫描程序的拆分功能,它返回每个空格分隔的文本单词,并删除周围的空格. 它永远不会返回空字符串. 空间的定义由unicode.IsSpace设置.

type ReadWriter

ReadWriter存储指向读取器和写入器的指针. 它实现io.ReadWriter.

type ReadWriter struct {
    *Reader
    *Writer
}

func NewReadWriter

func NewReadWriter(r *Reader, w *Writer) *ReadWriter

NewReadWriter分配一个新的ReadWriter,该新的ReadWriter调度到r和w.

type Reader

Reader为io.Reader对象实现缓冲.

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

func NewReader

func NewReader(rd io.Reader) *Reader

NewReader返回一个新的Reader,其缓冲区具有默认大小.

func NewReaderSize

func NewReaderSize(rd io.Reader, size int) *Reader

NewReaderSize返回一个新的Reader,其缓冲区至少具有指定的大小. 如果参数io.Reader已经是足够大的Reader,则它将返回基础Reader.

func (*Reader) Buffered

func (b *Reader) Buffered() int

Buffered返回可从当前缓冲区读取的字节数.

func (*Reader) Discard 1.5

func (b *Reader) Discard(n int) (discarded int, err error)

Discard跳过接下来的n个字节,返回丢弃的字节数.

如果"放弃"跳过少于n个字节,则它还会返回错误. 如果0 <= n <= b.Buffered(),则确保Discard成功执行,而无需从基础io.Reader中读取.

func (*Reader) Peek

func (b *Reader) Peek(n int) ([]byte, error)

Peek返回下一个n个字节,而不会使阅读器前进. 在下一个读取调用中,字节停止有效. 如果Peek返回的字节数少于n个字节,则它还会返回一个错误,解释读取短的原因. 如果n大于b的缓冲区大小,则错误为ErrBufferFull.

调用Peek会阻止UnreadByte或UnreadRune调用成功进行,直到下一次读取操作为止.

func (*Reader) Read

func (b *Reader) Read(p []byte) (n int, err error)

Read reads data into p. It returns the number of bytes read into p. The bytes are taken from at most one Read on the underlying Reader, hence n may be less than len(p). To read exactly len(p) bytes, use io.ReadFull(b, p). At EOF, the count will be zero and err will be io.EOF.

func (*Reader) ReadByte

func (b *Reader) ReadByte() (byte, error)

ReadByte读取并返回一个字节. 如果没有可用的字节,则返回错误.

func (*Reader) ReadBytes

func (b *Reader) ReadBytes(delim byte) ([]byte, error)

ReadBytes读取直到输入中第一次出现delim为止,并返回一个切片,该切片包含直到定界符(包括定界符)的数据. 如果ReadBytes在找到定界符之前遇到错误,它将返回错误之前读取的数据和错误本身(通常为io.EOF). 当且仅当返回的数据未以delim结尾时,ReadBytes返回err!= nil. 对于简单的用途,扫描仪可能更方便.

func (*Reader) ReadLine

func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

ReadLine是低级别的行读取原语. 大多数调用者应改用ReadBytes('\ n')或ReadString('\ n')或使用扫描仪.

ReadLine尝试返回单行,不包括行尾字节. 如果该行对于缓冲区而言太长,则设置isPrefix并返回该行的开头. 该行的其余部分将从以后的呼叫中返回. 返回行的最后一个片段时,isPrefix将为false. 返回的缓冲区仅在下一次调用ReadLine之前有效. ReadLine要么返回非零行,要么返回错误,从不都返回.

从ReadLine返回的文本不包含行尾(" \ r \ n"或" \ n"). 如果输入在没有最后一行的情况下结束,则不会给出任何指示或错误. 在ReadLine之后调用UnreadByte将始终不读取最后读取的字节(可能是属于行尾的字符),即使该字节不属于ReadLine返回的行的一部分.

func (*Reader) ReadRune

func (b *Reader) ReadRune() (r rune, size int, err error)

ReadRune读取单个UTF-8编码的Unicode字符,并返回符文及其大小(以字节为单位). 如果编码的符文无效,则它消耗一个字节并返回unicode.ReplacementChar(U + FFFD),大小为1.

func (*Reader) ReadSlice

func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

ReadSlice读取直到输入中第一次出现delim为止,并返回一个指向缓冲区中字节的切片. 字节在下一次读取时不再有效. 如果ReadSlice在找到定界符之前遇到错误,它将返回缓冲区中的所有数据以及错误本身(通常为io.EOF). 如果缓冲区填充不带delim,则ReadSlice失败,错误为ErrBufferFull. 由于从ReadSlice返回的数据将被下一个I / O操作覆盖,因此大多数客户端应改用ReadBytes或ReadString. 当且仅当行不以delim结尾时,ReadSlice才返回err!= nil.

func (*Reader) ReadString

func (b *Reader) ReadString(delim byte) (string, error)

ReadString读取直到输入中第一次出现delim为止,返回一个字符串,其中包含直到定界符(包括定界符)的数据. 如果ReadString在找到定界符之前遇到错误,它将返回错误之前读取的数据和错误本身(通常为io.EOF). 当且仅当返回的数据未以delim结尾时,ReadString才返回err!= nil. 对于简单的用途,扫描仪可能更方便.

func (*Reader) Reset 1.2

func (b *Reader) Reset(r io.Reader)

重置将丢弃所有缓冲的数据,重置所有状态,并将缓冲的读取器切换为从r读取.

func (*Reader) Size 1.10

func (b *Reader) Size() int

Size返回底层缓冲区的大小(以字节为单位).

func (*Reader) UnreadByte

func (b *Reader) UnreadByte() error

UnreadByte取消读取最后一个字节. 只有最近读取的字节可以不被读取.

如果在Reader上调用的最新方法不是读取操作,则UnreadByte返回错误. 值得注意的是,Peek不被视为读取操作.

func (*Reader) UnreadRune

func (b *Reader) UnreadRune() error

UnreadRune取消读取最后一个符文. 如果在Reader上调用的最新方法不是ReadRune,则UnreadRune返回错误. (在这方面,它比UnreadByte严格,它将从任何读取操作中读取最后一个字节.)

func (*Reader) WriteTo 1.1

func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

WriteTo实现io.WriterTo. 这可能会多次调用基础Reader的Read方法. 如果基础阅读器支持WriteTo方法,则此方法将调用基础WriteTo而不进行缓冲.

type Scanner 1.1

扫描仪提供了一个方便的界面来读取数据,例如用换行符分隔的文本行的文件. 连续调用Scan方法将逐步浏览文件的"令牌",跳过令牌之间的字节. 令牌的规范是由SplitFunc类型的split函数定义的; 默认的split功能将输入分成几行,并去除了行进终端​​. 在此软件包中定义了拆分功能,用于将文件扫描为行,字节,UTF-8编码的符文和空格分隔的单词. 客户端可以改为提供自定义拆分功能.

扫描在EOF,第一个I / O错误或令牌太大而无法容纳在缓冲区中时停止恢复. 当扫描停止时,读取器可能会任意前进,远远超过最后一个标记. 需要对错误处理或较大令牌进行更多控制的程序,或者必须在读取器上运行顺序扫描的程序,应改用bufio.Reader.

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

示例(自定义)

使用具有自定义拆分功能(通过包装ScanWords构建)的扫描仪来验证32位十进制输入.

1234
5678
Invalid input: strconv.ParseInt: parsing "1234567901234567890": value out of range

示例(EmptyFinalToken)

Use a Scanner with a custom split function to parse a comma-separated list with an empty final value.

"1" "2" "3" "4" ""

示例(行)

扫描仪的最简单用法,是将标准输入读取为一组行.

例子(单词)

使用扫描程序通过将输入扫描为一系列以空格分隔的标记来实现简单的字数统计实用程序.

15

func NewScanner 1.1

func NewScanner(r io.Reader) *Scanner

NewScanner返回一个新的Scanner以从r中读取. 拆分功能默认为ScanLines.

func (*Scanner) Buffer 1.6

func (s *Scanner) Buffer(buf []byte, max int)

缓冲区设置扫描时要使用的初始缓冲区以及在扫描过程中可能分配的缓冲区的最大大小. 最大令牌大小是max和cap(buf)中的较大者. 如果max <= cap(buf),Scan将仅使用此缓冲区,并且不分配.

默认情况下,扫描使用内部缓冲区并将最大令牌大小设置为MaxScanTokenSize.

如果在扫描开始后调用缓冲区恐慌.

func (*Scanner) Bytes 1.1

func (s *Scanner) Bytes() []byte

字节返回通过调用Scan生成的最新令牌. 基础数组可能指向将由后续对Scan的调用覆盖的数据. 它不分配.

Example

以[]字节的形式返回对Scan的最新调用.

true

func (*Scanner) Err 1.1

func (s *Scanner) Err() error

Err返回扫描仪遇到的第一个非EOF错误.

func (*Scanner) Scan 1.1

func (s *Scanner) Scan() bool

扫描将扫描程序前进到下一个令牌,然后可以通过Bytes或Text方法使用该令牌. 当扫描停止时(到达输入末尾或出现错误),它返回false. 在Scan返回false之后,Err方法将返回扫描期间发生的任何错误,但如果是io.EOF,Err将返回nil. 如果split函数在不提前输入的情况下返回了太多的空令牌,请扫描恐慌. 这是扫描仪的常见错误模式.

func (*Scanner) Split 1.1

func (s *Scanner) Split(split SplitFunc)

分割设置扫描仪的分割功能. 默认的拆分功能是ScanLines.

如果在扫描开始后调用了panic,则将其拆分.

func (*Scanner) Text 1.1

func (s *Scanner) Text() string

文本将通过调用Scan生成的最新令牌作为保留其字节的新分配的字符串返回.

type SplitFunc 1.1

SplitFunc是用于对输入进行标记化的split函数的签名. 参数是剩余的未处理数据的初始子字符串,以及标志atEOF,该标志报告Reader是否没有更多数据可提供. 返回值是推进输入的字节数,以及返回给用户的下一个令牌(如果有)以及错误(如果有).

如果函数返回错误,扫描将停止,在这种情况下,某些输入可能会被丢弃.

否则,扫描仪将前进输入. 如果令牌不是nil,则扫描程序会将其返回给用户. 如果令牌为零,则扫描程序将读取更多数据并继续扫描;否则,将继续扫描. 如果没有更多数据-如果atEOF为true-扫描程序将返回. 如果数据还没有完整的令牌,例如,如果在扫描行时没有换行符,则SplitFunc可以返回(0,nil,nil),以指示扫描程序将更多数据读入切片中,并尝试使用更长的时间切片从输入中的同一点开始.

除非atEOF为true,否则永远不要使用空数据片调用该函数. 但是,如果atEOF为true,则数据可能为非空,并且一如既往地保留未处理的文本.

type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

type Writer

Writer为io.Writer对象实现缓冲. 如果在写入Writer时发生错误,将不再接受更多数据,并且所有后续写入和Flush都将返回错误. 写入所有数据之后,客户端应调用Flush方法以确保所有数据都已转发到基础io.Writer.

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

Example

Hello, world!

func NewWriter

func NewWriter(w io.Writer) *Writer

NewWriter返回一个新的Writer,其缓冲区具有默认大小.

func NewWriterSize

func NewWriterSize(w io.Writer, size int) *Writer

NewWriterSize返回一个新的Writer,其缓冲区至少具有指定的大小. 如果参数io.Writer已经是一个足够大的Writer,则它将返回基础Writer.

func (*Writer) Available

func (b *Writer) Available() int

Available返回缓冲区中未使用的字节数.

func (*Writer) Buffered

func (b *Writer) Buffered() int

Buffered返回已写入当前缓冲区的字节数.

func (*Writer) Flush

func (b *Writer) Flush() error

刷新会将所有缓冲的数据写入基础io.Writer.

func (*Writer) ReadFrom 1.1

func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)

ReadFrom实现io.ReaderFrom. 如果基础编写器支持ReadFrom方法,并且b尚无缓冲数据,则这将调用基础ReadFrom而不进行缓冲.

func (*Writer) Reset 1.2

func (b *Writer) Reset(w io.Writer)

复位将丢弃所有未刷新的缓冲数据,清除所有错误,然后复位b将其输出写入w.

func (*Writer) Size 1.10

func (b *Writer) Size() int

Size返回底层缓冲区的大小(以字节为单位).

func (*Writer) Write

func (b *Writer) Write(p []byte) (nn int, err error)

写操作将p的内容写入缓冲区. 它返回写入的字节数. 如果nn <len(p),它还会返回一个错误,解释为什么写时间短.

func (*Writer) WriteByte

func (b *Writer) WriteByte(c byte) error

WriteByte写入一个字节.

func (*Writer) WriteRune

func (b *Writer) WriteRune(r rune) (size int, err error)

WriteRune写入单个Unicode代码点,返回写入的字节数和任何错误.

func (*Writer) WriteString

func (b *Writer) WriteString(s string) (int, error)

WriteString写一个字符串. 它返回写入的字节数. 如果计数小于len,它还会返回一个错误,解释为什么写时间短.

by  ICOPY.SITE