Go bufio包

原创
2017/02/10 19:17
阅读数 74

Go bufio包

Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O.

bufio.Reader结构体

// Reader implements buffering for an io.Reader object.
type Reader struct {
	buf          []byte
	rd           io.Reader // reader provided by the client
	r, w         int       // buf read and write positions
	err          error
	lastByte     int
	lastRuneSize int
}

所有的方法,

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) UnreadByte() error
func (b *Reader) UnreadRune() error
func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

使用示例,

package main

import (
	"bytes"
	"bufio"
	"fmt"
)

func main() {
	b1 := []byte("hello world!")
	rd := bytes.NewReader(b1)
	buf := bufio.NewReader(rd) //默认的缓冲区大小是 4096

	fmt.Printf("1.the number of bytes that can be read from the current buffer=%d\n", buf.Buffered())

	b2 := make([]byte, 5)
	buf.Read(b2)
	println(string(b2))
	fmt.Printf("2.the number of bytes that can be read from the current buffer=%d\n", buf.Buffered())

	d, _ := buf.Discard(1)
	fmt.Printf("3.the number of discard bytes =%d\n", d)

	b3 := make([]byte, 5)
	buf.Read(b3)
	println(string(b3))
	fmt.Printf("4.the number of bytes that can be read from the current buffer=%d\n", buf.Buffered())

	fmt.Println("--------------")
	rd2 := bytes.NewReader([]byte("hello world"))
	buf2 := bufio.NewReader(rd2)
	// Peek 返回缓存的一个切片,该切片引用缓存中前 n 个字节的数据,
	// 该操作不会将数据读出,只是引用,引用的数据在下一次读取操作之
	// 前是有效的。如果切片长度小于 n,则返回一个错误信息说明原因。
	// 如果 n 大于缓存的总大小,则返回 ErrBufferFull。
	b4, _ := buf2.Peek(5)
	println(string(b4))
	b4[0] = 'a'
	b4[1] = 'a'
	b4[2] = 'a'
	b4[3] = 'a'
	b4[4] = 'a'
	fmt.Printf("5.the number of bytes that can be read from the current buffer=%d\n", buf2.Buffered())

	for {
		b, err := buf2.ReadByte()
		if err != nil {
			break
		}
		fmt.Print(string(b)) // aaaaa world
	}
}

 

bufio.Writer结构体

// Writer implements buffering for an io.Writer object.
// If an error occurs writing to a Writer, no more data will be
// accepted and all subsequent writes will return the error.
// After all data has been written, the client should call the
// Flush method to guarantee all data has been forwarded to
// the underlying io.Writer.
type Writer struct {
	err error
	buf []byte
	n   int
	wr  io.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) 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 main

import (
	"bufio"
	"os"
	"fmt"
)

func main() {

	buf := bufio.NewWriterSize(os.Stdout, 0)
	fmt.Println(buf.Available(), buf.Buffered())

	buf.WriteString("hello world")
	fmt.Println(buf.Available(), buf.Buffered())

	str := "我是中国人"
	for _, ele := range []rune(str) {
		buf.WriteRune(ele)
	}
	// 缓存后统一输出,避免终端频繁刷新,影响速度
	buf.Flush()

}

 

bufio.Scanner结构体

// Scanner provides a convenient interface for reading data such as
// a file of newline-delimited lines of text. Successive calls to
// the Scan method will step through the 'tokens' of a file, skipping
// the bytes between the tokens. The specification of a token is
// defined by a split function of type SplitFunc; the default split
// function breaks the input into lines with line termination stripped. Split
// functions are defined in this package for scanning a file into
// lines, bytes, UTF-8-encoded runes, and space-delimited words. The
// client may instead provide a custom split function.
//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the buffer. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans
// on a reader, should use bufio.Reader instead.
//
type Scanner struct {
	r            io.Reader // The reader provided by the client.
	split        SplitFunc // The function to split the tokens.
	maxTokenSize int       // Maximum size of a token; modified by tests.
	token        []byte    // Last token returned by split.
	buf          []byte    // Buffer used as argument to split.
	start        int       // First non-processed byte in buf.
	end          int       // End of data in buf.
	err          error     // Sticky error.
	empties      int       // Count of successive empty tokens.
	scanCalled   bool      // Scan has been called; buffer is in use.
	done         bool      // Scan has finished.
}

所有的方法,

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

方法使用示例,

package main

import (
	"os"
	"bufio"
	"fmt"
)

func main() {

	var path = "/Users/xinxingegeya/workspace-go/src/awesomeProject/bufio/temp.txt"
	file, _ := os.Open(path)
	scanner := bufio.NewScanner(file)
	// Split 用于设置“匹配函数”,这个函数必须在调用 Scan 前执行。
	scanner.Split(bufio.ScanLines)

	// Scan 开始一次扫描过程,如果匹配成功,可以通过 Bytes() 或 Text() 方法取出结果,
	// 如果遇到错误,则终止扫描,并返回 false。
	for scanner.Scan() {
		var record = scanner.Text()
		fmt.Println(record)
	}
}

 

bufio.ReaderWriter结构体

// buffered input and output

// ReadWriter stores pointers to a Reader and a Writer.
// It implements io.ReadWriter.
type ReadWriter struct {
	*Reader
	*Writer
}

所有的方法,

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

=======END=======

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部