精确控制 fmt.Fscanf 空白字符消耗的策略与实践

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "log"
)

func main() {
    // 模拟PPM文件头输入，注意Maxval后的单个换行符
    ppmHeader := "P6 640 480 255\n"
    // 紧接着是二进制数据，这里用占位符表示
    imageData := []byte{0x01, 0x02, 0x03, 0x04, 0x05}

    // 将头部和数据合并成一个Reader
    inputReader := io.MultiReader(bytes.NewReader([]byte(ppmHeader)), bytes.NewReader(imageData))

    // 使用bufio.NewReader包装原始Reader
    buf := bufio.NewReader(inputReader)

    var magic string
    var width, height, maxVal uint

    // 使用Fscanf解析头部信息
    // 注意：这里不包含额外的格式符来处理最后的空白字符
    n, err := fmt.Fscanf(buf, "%2s %d %d %d", &magic, &width, &height, &maxVal)
    if err != nil {
        log.Fatalf("Error parsing PPM header: %v", err)
    }
    fmt.Printf("Parsed %d items: Magic=%s, Width=%d, Height=%d, MaxVal=%d\n", n, magic, width, height, maxVal)

    // Fscanf在读取完MaxVal后，会读取其后的空白字符，并尝试匹配下一个格式符。
    // 由于没有下一个格式符，它会尝试将这个空白字符UnreadRune。
    // 因为bufio.Reader支持UnreadRune，所以这个空白字符会被放回缓冲区。
    // 我们需要手动读取并消耗掉这个最后的空白字符，以确保后续读取从二进制数据开始。
    r, size, err := buf.ReadRune()
    if err != nil {
        log.Fatalf("Error reading final whitespace: %v", err)
    }
    fmt.Printf("Consumed final whitespace: '%c' (size: %d)\n", r, size)

    // 此时，Reader指针应该正好指向二进制数据的开头
    // 尝试读取一些二进制数据
    remainingData := make([]byte, 5)
    bytesRead, err := buf.Read(remainingData)
    if err != nil && err != io.EOF {
        log.Fatalf("Error reading image data: %v", err)
    }
    fmt.Printf("Read %d bytes of image data: %x\n", bytesRead, remainingData[:bytesRead])

    // 验证读取到的二进制数据是否正确
    if bytes.Equal(remainingData[:bytesRead], imageData[:bytesRead]) {
        fmt.Println("Binary data read successfully from correct position.")
    } else {
        fmt.Println("Error: Binary data mismatch.")
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "log"
)

func main() {
    // 模拟PPM文件头输入，注意Maxval后的单个换行符
    ppmHeader := "P6 640 480 255\n"
    // 紧接着是二进制数据
    imageData := []byte{0x01, 0x02, 0x03, 0x04, 0x05}

    // 将头部和数据合并成一个Reader
    inputReader := io.MultiReader(bytes.NewReader([]byte(ppmHeader)), bytes.NewReader(imageData))

    var magic string
    var width, height, maxVal uint
    var dummy byte // 用于接收最后一个空白字符

    // 使用Fscanf解析头部信息，并用%c匹配最后一个空白字符
    n, err := fmt.Fscanf(inputReader, "%2s %d %d %d%c", &magic, &width, &height, &maxVal, &dummy)
    if err != nil {
        log.Fatalf("Error parsing PPM header: %v", err)
    }
    fmt.Printf("Parsed %d items: Magic=%s, Width=%d, Height=%d, MaxVal=%d, DummyChar='%c'\n", n, magic, width, height, maxVal, dummy)

    // 此时，Reader指针应该正好指向二进制数据的开头
    // 尝试读取一些二进制数据
    remainingData := make([]byte, 5)
    bytesRead, err := inputReader.Read(remainingData)
    if err != nil && err != io.EOF {
        log.Fatalf("Error reading image data: %v", err)
    }
    fmt.Printf("Read %d bytes of image data: %x\n", bytesRead, remainingData[:bytesRead])

    // 验证读取到的二进制数据是否正确
    if bytes.Equal(remainingData[:bytesRead], imageData[:bytesRead]) {
        fmt.Println("Binary data read successfully from correct position.")
    } else {
        fmt.Println("Error: Binary data mismatch.")
    }
}

package main

import (
    "bytes"
    "io"
    "fmt"
    "testing"
)

// TestFmtBehavior 验证 fmt.Fscanf 在处理末尾空白字符时的行为
func TestFmtBehavior(t *testing.T) {
    // 使用 io.MultiReader 防止 r 意外地实现 io.RuneScanner 接口，
    // 这样可以模拟最坏情况（底层Reader不支持UnreadRune）。
    // "data  " 包含一个数据字符串和两个空格。
    // 我们期望 %s 匹配 "data"，%c 匹配第一个空格。
    // 理论上，Fscanf 在匹配 %c 时会多读一个字符（第二个空格），
    // 如果底层Reader不支持UnreadRune，这个字符就会被消耗掉。
    // 但在 `%s%c` 的情况下，Fscanf 在匹配 `%c` 时会把紧随 `%s` 的空白字符作为 `%c` 的值，
    // 而不会再多读一个字符。
    // 所以，如果输入是 "data  "，%s 得到 "data"，%c 得到 ' ' (第一个空格)。
    // 剩余输入流中应该只剩下一个空格。
    r := io.MultiReader(bytes.NewReader([]byte("data  ")))

    var s string
    var c byte

    // 尝试解析字符串和紧随其后的一个字符
    n, err := fmt.Fscanf(r, "%s%c", &s, &c)
    if err != nil {
        t.Errorf("fmt.Fscanf failed: %v", err)
    }

    // 验证解析的项数和值
    if n != 2 {
        t.Errorf("Expected to scan 2 items, got %d", n)
    }
    if s != "data" {
        t.Errorf("Expected string 'data', got '%s'", s)
    }
    if c != ' ' { // 期望匹配第一个空格
        t.Errorf("Expected char ' ', got '%c'", c)
    }

    // 验证剩余输入流中是否还存在一个字符（第二个空格）
    remaining := make([]byte, 5)
    bytesRead, err := r.Read(remaining)
    if err != nil && err != io.EOF {
        t.Errorf("Error reading remaining data: %v", err)
    }

    // 期望剩余一个字节（第二个空格）
    if bytesRead != 1 {
        t.Errorf("Expected 1 byte remaining, got %d", bytesRead)
    }
    if remaining[0] != ' ' {
        t.Errorf("Expected remaining byte to be ' ', got '%c'", remaining[0])
    }
}