Go语言中fmt.Fscanf精确控制空白字符消耗的策略

var magic string
var width, height, maxVal uint

// input 是一个 io.Reader
fmt.Fscanf(input, "%2s %d %d %d", &magic, &width, &height, &maxVal)

package main

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

func main() {
    // 模拟PPM头数据： "P6 640 480 255\n" 后紧跟二进制数据
    header := []byte("P6 640 480 255\n")
    imageData := []byte{0x01, 0x02, 0x03, 0x04} // 模拟图像数据
    inputReader := io.MultiReader(bytes.NewReader(header), bytes.NewReader(imageData))

    // 将原始io.Reader包装成bufio.Reader
    buf := bufio.NewReader(inputReader)

    var magic string
    var width, height, maxVal uint

    // 使用fmt.Fscanf解析头部，不包含最后的空白符
    // fmt.Fscanf会读取到MaxVal后的第一个非空白字符，但因为bufio.Reader支持UnreadRune，
    // 那个非空白字符（这里是图像数据的第一个字节0x01）会被回退
    n, err := fmt.Fscanf(buf, "%2s %d %d %d", &magic, &width, &height, &maxVal)
    if err != nil {
        fmt.Printf("Error scanning header: %v\n", err)
        return
    }
    fmt.Printf("Scanned %d items: Magic=%s, Width=%d, Height=%d, MaxVal=%d\n", n, magic, width, height, maxVal)

    // 显式读取并丢弃最后一个空白字符（换行符）
    // ReadRune()会从缓冲区中移除下一个rune
    r, _, err := buf.ReadRune()
    if err != nil {
        fmt.Printf("Error reading final whitespace: %v\n", err)
        return
    }
    fmt.Printf("Consumed final whitespace: '%c' (U+%04X)\n", r, r)

    // 此时，输入流指针应该正好指向图像数据的起始
    // 我们可以尝试读取图像数据的第一个字节进行验证
    firstImageDataByte, err := buf.ReadByte()
    if err != nil {
        fmt.Printf("Error reading first image data byte: %v\n", err)
        return
    }
    fmt.Printf("First image data byte: 0x%02X (Expected: 0x%02X)\n", firstImageDataByte, imageData[0])

    // 验证结果
    if firstImageDataByte == imageData[0] {
        fmt.Println("Image data stream correctly positioned.")
    } else {
        fmt.Println("Error: Image data stream mispositioned.")
    }
}

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

fmt.Fscanf(input, "%2s %d %d %d%c", &magic, &width, &height, &maxVal, &dummy)

package main

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

func TestFmtBehavior(t *testing.T) {
    // 使用io.MultiReader来确保r不实现io.RuneScanner，
    // 从而模拟fmt.Fscanf在没有UnreadRune时可能出现的行为。
    // "data  " 后有两个空格，我们期望fmt.Fscanf读取"data"和第一个空格。
    // 第二个空格应该被保留。
    r := io.MultiReader(bytes.NewReader([]byte("data  "))) // 注意这里是两个空格

    var s string
    var c byte

    // 期望读取一个字符串和一个字符。
    // fmt.Fscanf("%s%c", ...) 会读取 "data" 和第一个空格。
    // 此时，fmt.Fscanf会尝试读取下一个字符（第二个空格）来判断%c的结束，
    // 但由于r没有UnreadRune，这个字符可能被消耗。
    n, err := fmt.Fscanf(r, "%s%c", &s, &c)

    if n != 2 || err != nil {
        t.Errorf("Failed scan: n=%d, err=%v. Expected n=2, err=nil", n, err)
    }
    if s != "data" {
        t.Errorf("String mismatch: got %q, want %q", s, "data")
    }
    if c != ' ' { // 期望读取到第一个空格
        t.Errorf("Char mismatch: got %q, want %q", c, ' ')
    }

    // 此时，输入流中应该还剩一个字节（第二个空格）。
    // 如果fmt.Fscanf在没有UnreadRune的情况下多读了一个字符（第二个空格）但没有回退，
    // 那么这里将读不到任何东西。
    remaining := make([]byte, 5)
    bytesRead, err := r.Read(remaining)

    // 期望还能读取到一个字节（第二个空格）
    if bytesRead != 1 || err != nil {
        t.Errorf("Assertion failed: bytesRead=%d, err=%v. Expected bytesRead=1, err=nil", bytesRead, err)
    }
    if remaining[0] != ' ' {
        t.Errorf("Remaining byte mismatch: got %q, want %q", remaining[0], ' ')
    }
    fmt.Printf("Test passed: String=%q, Char=%q, Remaining byte=%q\n", s, c, remaining[0])
}