bufio

package main

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

func main() {
    w := bufio.NewWriter(os.Stdout)
    fmt.Fprint(w, "Hello, ")
    fmt.Fprint(w, "world!")
    w.Flush() // Don't forget to flush!
}

package main

import (
    "bufio"
    "fmt"
    "strconv"
    "strings"
)

func main() {
    // An artificial input source.
    const input = "1234 5678 1234567901234567890"
    scanner := bufio.NewScanner(strings.NewReader(input))
    // Create a custom split function by wrapping the existing ScanWords function.
    split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
        advance, token, err = bufio.ScanWords(data, atEOF)
        if err == nil && token != nil {
            _, err = strconv.ParseInt(string(token), 10, 32)
        }
        return
    }
    // Set the split function for the scanning operation.
    scanner.Split(split)
    // Validate the input
    for scanner.Scan() {
        fmt.Printf("%s\n", scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        fmt.Printf("Invalid input: %s", err)
    }
}

package main

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

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        fmt.Println("input: ", scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "reading standard input: ", err)
    }
}

package main

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

func main() {
    // An artificial input source.
    const input = "Now is the winter of our discontent,\nMade glorious summer by this sun of York.\n"
    scanner := bufio.NewScanner(strings.NewReader(input))
    // Set the split function for the scanning operation.
    scanner.Split(bufio.ScanWords)
    // Count the words.
    count := 0
    for scanner.Scan() {
        count++
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "reading input:", err)
    }
    fmt.Printf("%d\n", count)
}

 bufio.Reader

package main

import (
    "bufio"
    "fmt"
    "strings"
)

func main() {
    sr := strings.NewReader("ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
    buf := bufio.NewReaderSize(sr, 0)
    b := make([]byte, 10)

    fmt.Println(buf.Buffered()) // 0
    s, _ := buf.Peek(5)
    /*
    // Peek 返回缓存的一个切片，该切片引用缓存中前 n 个字节的数据，
    // 该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之
    // 前是有效的。如果切片长度小于 n，则返回一个错误信息说明原因。
    // 如果 n 大于缓存的总大小，则返回 ErrBufferFull。
    func (b *Reader) Peek(n int) ([]byte, error)
    */
    s[0], s[1], s[2] = 'a', 'b', 'c'
    fmt.Printf("%d   %q\n", buf.Buffered(), s) // 16   "abcDE"

    buf.Discard(1)
    /*
    // Discard 跳过后续的 n 个字节的数据，返回跳过的字节数。
    // 如果结果小于 n，将返回错误信息。
    // 如果 n 小于缓存中的数据长度，则不会从底层提取数据。
    func (b *Reader) Discard(n int) (discarded int, err error)
    */
    for n, err := 0, error(nil); err == nil; {
        n, err = buf.Read(b)
        fmt.Printf("%d   %q   %v\n", buf.Buffered(), b[:n], err)
    }
}

 

package main

import (
    "bufio"
    "fmt"
    "strings"
)

// 示例：ReadLine
func main() {
    sr := strings.NewReader("ABCDEFGHIJKLMNOPQRSTUVWXYZ\n1234567890")
    buf := bufio.NewReaderSize(sr, 0)

    for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
        line, isPrefix, err = buf.ReadLine()
        fmt.Printf("%q   %t   %v\n", line, isPrefix, err)
    }
    // "ABCDEFGHIJKLMNOP"   true   <nil>
    // "QRSTUVWXYZ"   false   <nil>
    // "1234567890"   false   <nil>
    // ""   false   EOF

    fmt.Println("----------")

    // 尾部有一个换行标记
    buf = bufio.NewReaderSize(strings.NewReader("ABCDEFG\n"), 0)

    for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
        line, isPrefix, err = buf.ReadLine()
        fmt.Printf("%q   %t   %v\n", line, isPrefix, err)
    }
    // "ABCDEFG"   false   <nil>
    // ""   false   EOF

    fmt.Println("----------")

    // 尾部没有换行标记
    buf = bufio.NewReaderSize(strings.NewReader("ABCDEFG"), 0)

    for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
        line, isPrefix, err = buf.ReadLine()
        fmt.Printf("%q   %t   %v\n", line, isPrefix, err)
    }
    // "ABCDEFG"   false   <nil>
    // ""   false   EOF
}

 

package main

import (
    "bufio"
    "fmt"
    "strings"
)

// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据。
// 该操作会读出数据，返回的切片是已读出的数据的引用，切片中的数据
// 在下一次读取操作之前是有效的。
//
// 如果找到 delim，则返回查找结果，err 返回 nil。
// 如果未找到 delim，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，err 返回 ErrBufferFull。
//
// 如果未找到 delim 且遇到错误（通常是 io.EOF），则返回缓存中的所
// 有数据和遇到的错误。
//
// 因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该
// 使用 ReadBytes 或 ReadString，它们返回的是数据的拷贝。
//func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

// 示例：ReadSlice
func main() {
    // 尾部有换行标记
    buf := bufio.NewReaderSize(strings.NewReader("ABCDEFG\n"), 0)

    for line, err := []byte{0}, error(nil); len(line) > 0 && err == nil; {
        line, err = buf.ReadSlice('\n')
        fmt.Printf("%q   %v\n", line, err)
    }
    // "ABCDEFG\n"   <nil>
    // ""   EOF

    fmt.Println("----------")

    // 尾部没有换行标记
    buf = bufio.NewReaderSize(strings.NewReader("ABCDEFG"), 0)

    for line, err := []byte{0}, error(nil); len(line) > 0 && err == nil; {
        line, err = buf.ReadSlice('\n')
        fmt.Printf("%q   %v\n", line, err)
    }
    // "ABCDEFG"   EOF
}

 bufio.Writer

package main

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

func main() {
    buf := bufio.NewWriterSize(os.Stdout, 0)
    fmt.Println(buf.Available(), buf.Buffered()) // 4096 0

    buf.WriteString("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    fmt.Println(buf.Available(), buf.Buffered()) // 4070 26

    // 缓存后统一输出，避免终端频繁刷新，影响速度
    buf.Flush() // ABCDEFGHIJKLMNOPQRSTUVWXYZ
}

bufio.ReaderWriter

// 顾名思义: bufio.ReaderWriter综合了Reader和Writer两者的功能
// ReadWriter 集成了 bufio.Reader 和 bufio.Writer
type ReadWriter struct {
    *Reader
    *Writer
}

// NewReadWriter 将 r 和 w 封装成一个 bufio.ReadWriter 对象
func NewReadWriter(r *Reader, w *Writer) *ReadWriter

bufio.Scanner

// 主要用于指定匹配函数，进行文本扫描，返回匹配结果
// 自定义匹配函数中，支持正则表达式进行匹配
// Scanner 提供了一个方便的接口来读取数据，例如遍历多行文本中的行。Scan 方法会通过
// 一个“匹配函数”读取数据中符合要求的部分，跳过不符合要求的部分。“匹配函数”由调
// 用者指定。本包中提供的匹配函数有“行匹配函数”、“字节匹配函数”、“字符匹配函数”
// 和“单词匹配函数”，用户也可以自定义“匹配函数”。默认的“匹配函数”为“行匹配函
// 数”，用于获取数据中的一行内容（不包括行尾标记）
//
// Scanner 使用了缓存，所以匹配部分的长度不能超出缓存的容量。默认缓存容量为 4096 -
// bufio.MaxScanTokenSize，用户可以通过 Buffer 方法指定自定义缓存及其最大容量。
//
// Scan 在遇到下面的情况时会终止扫描并返回 false（扫描一旦终止，将无法再继续）：
// 1、遇到 io.EOF
// 2、遇到读写错误
// 3、“匹配部分”的长度超过了缓存的长度
//
// 如果需要对错误进行更多的控制，或“匹配部分”超出缓存容量，或需要连续扫描，则应该
// 使用 bufio.Reader
type Scanner struct { ... }

// NewScanner 创建一个 Scanner 来扫描 r，默认匹配函数为 ScanLines。
func NewScanner(r io.Reader) *Scanner

// Buffer 用于设置自定义缓存及其可扩展范围，如果 max 小于 len(buf)，则 buf 的尺寸将
// 固定不可调。Buffer 必须在第一次 Scan 之前设置，否则会引发 panic。
// 默认情况下，Scanner 会使用一个 4096 - bufio.MaxScanTokenSize 大小的内部缓存。
func (s *Scanner) Buffer(buf []byte, max int)

// Split 用于设置“匹配函数”，这个函数必须在调用 Scan 前执行。
func (s *Scanner) Split(split SplitFunc)

// SplitFunc 用来定义“匹配函数”，data 是缓存中的数据。atEOF 标记数据是否读完。
// advance 返回 data 中已处理的数据的长度。token 返回找到的“匹配部分”，“匹配
// 部分”可以是缓存的切片，也可以是自己新建的数据（比如 bufio.errorRune）。“匹
// 配部分”将在 Scan 之后通过 Bytes 和 Text 反馈给用户。err 返回错误信息。
//
// 如果在 data 中无法找到一个完整的“匹配部分”则应返回 (0, nil, nil)，以便告诉
// Scanner 向缓存中填充更多数据，然后再次扫描（Scan 会自动重新扫描）。如果缓存已
// 经达到最大容量还没有找到，则 Scan 会终止并返回 false。
// 如果 data 为空，则“匹配函数”将不会被调用，意思是在“匹配函数”中不必考虑
// data 为空的情况。
//
// 如果 err != nil，扫描将终止，如果 err == ErrFinalToken，则 Scan 将返回 true，
// 表示扫描正常结束，如果 err 是其它错误，则 Scan 将返回 false，表示扫描出错。错误
// 信息可以在 Scan 之后通过 Err 方法获取。
//
// SplitFunc 的作用很简单，从 data 中找出你感兴趣的数据，然后返回，同时返回已经处理
// 的数据的长度。
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

// Scan 开始一次扫描过程，如果匹配成功，可以通过 Bytes() 或 Text() 方法取出结果，
// 如果遇到错误，则终止扫描，并返回 false。
func (s *Scanner) Scan() bool

// Bytes 将最后一次扫描出的“匹配部分”作为一个切片引用返回，下一次的 Scan 操作会覆
// 盖本次引用的内容。
func (s *Scanner) Bytes() []byte

// Text 将最后一次扫描出的“匹配部分”作为字符串返回（返回副本）。
func (s *Scanner) Text() string

// Err 返回扫描过程中遇到的非 EOF 错误，供用户调用，以便获取错误信息。
func (s *Scanner) Err() error

// ScanBytes 是一个“匹配函数”用来找出 data 中的单个字节并返回。
func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)

// ScanRunes 是一个“匹配函数”，用来找出 data 中单个 UTF8 字符的编码。如果 UTF8 编
// 码错误，则 token 会返回 "\xef\xbf\xbd"（即：U+FFFD），但只消耗 data 中的一个字节。
// 这使得调用者无法区分“真正的U+FFFD字符”和“解码错误的返回值”。
func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)

// ScanLines 是一个“匹配函数”，用来找出 data 中的单行数据并返回（包括空行）。
// 行尾标记可以是 \n 或 \r\n（返回值不包含行尾标记）
func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)

// ScanWords 是一个“匹配函数”，用来找出 data 中以空白字符分隔的单词。
// 空白字符由 unicode.IsSpace 定义。
func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)

------------------------------

// 示例：扫描
func main() {
    // 逗号分隔的字符串，最后一项为空
    const input = "1,2,3,4,"
    scanner := bufio.NewScanner(strings.NewReader(input))
    // 定义匹配函数（查找逗号分隔的字符串）
    onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
        for i := 0; i < len(data); i++ {
            if data[i] == ',' {
                return i + 1, data[:i], nil
            }
        }
        if atEOF {
            // 告诉 Scanner 扫描结束。
            return 0, data, bufio.ErrFinalToken
        } else {
            // 告诉 Scanner 没找到匹配项，让 Scan 填充缓存后再次扫描。
            return 0, nil, nil
        }
    }
    // 指定匹配函数
    scanner.Split(onComma)
    // 开始扫描
    for scanner.Scan() {
        fmt.Printf("%q ", scanner.Text())
    }
    // 检查是否因为遇到错误而结束
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "reading input:", err)
    }
}
--------------------------------------------------------------------------
// 示例：带检查扫描
func main() {
    const input = "1234 5678 1234567901234567890 90"
    scanner := bufio.NewScanner(strings.NewReader(input))
    // 自定义匹配函数
    split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
        // 获取一个单词
        // ScanBytes、ScanWords、ScanLines这些函数主用于筛选出相应的byte、word、line
        // 然后用于自定义匹配函数中进行匹配
        advance, token, err = bufio.ScanWords(data, atEOF)
        // 判断其能否转换为整数，如果不能则返回错误
        if err == nil && token != nil {
            _, err = strconv.ParseInt(string(token), 10, 32)
        }
        // 这里包含了 return 0, nil, nil 的情况
        return
    }
    // 设置匹配函数
    scanner.Split(split)
    // 开始扫描
    for scanner.Scan() {
        fmt.Printf("%s\n", scanner.Text())
    }
    // 扫描至1234567901234567890处，便会报错抛出异常，停止scan
    if err := scanner.Err(); err != nil {
        fmt.Printf("Invalid input: %s", err)
    }
}