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)

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

// 尝试通过 %c 强制消费一个字符
fmt.Fscanf(input, "%2s %d %d %d%c", &magic, &width, &height, &maxVal, &dummy)

package main

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

func parsePPMHeader(input io.Reader) (magic string, width, height, maxVal uint, err error) {
    // 1. 包装原始 io.Reader 为 *bufio.Reader
    buf := bufio.NewReader(input)

    // 2. 使用 fmt.Fscanf 解析主体数据，不包含最后的空白占位符
    // 注意：这里的格式字符串末尾没有额外的空白或 %c
    n, err := fmt.Fscanf(buf, "%2s %d %d %d", &magic, &width, &height, &maxVal)
    if err != nil {
        return "", 0, 0, 0, fmt.Errorf("failed to scan PPM header fields: %w", err)
    }
    if n != 4 { // 确保所有4个字段都被成功解析
        return "", 0, 0, 0, fmt.Errorf("expected 4 fields, got %d", n)
    }

    // 3. 手动消费最后的空白字符
    // 此时，fmt.Fscanf 已经完成了对 %d (maxVal) 的解析，并且可能预读了 maxVal 后的第一个字符。
    // 由于 buf 是一个 bufio.Reader，这个预读的字符会被 UnreadRune 推回。
    // 所以，我们现在需要手动读取并丢弃 maxVal 后的那个空白字符。
    r, _, err := buf.ReadRune()
    if err != nil {
        return "", 0, 0, 0, fmt.Errorf("failed to read final whitespace: %w", err)
    }
    if !isWhitespace(r) { // 验证读取到的是否确实是空白字符
        return "", 0, 0, 0, fmt.Errorf("expected whitespace after maxVal, got '%c'", r)
    }

    return magic, width, height, maxVal, nil
}

// 辅助函数：判断字符是否为空白
func isWhitespace(r rune) bool {
    return r == ' ' || r == '\t' || r == '\n' || r == '\r'
}

func main() {
    // 模拟一个 PPM 头部的输入流
    ppmHeader := "P6 640 480 255\n"
    // 紧接着是二进制数据，用一些字符模拟
    imageData := "ABCDEFGHIJ"
    inputString := ppmHeader + imageData

    // 使用 bytes.NewReader 模拟文件输入
    reader := bytes.NewReader([]byte(inputString))

    magic, width, height, maxVal, err := parsePPMHeader(reader)
    if err != nil {
        log.Fatalf("Error parsing PPM header: %v", err)
    }

    fmt.Printf("Parsed PPM Header:\n")
    fmt.Printf("  Magic: %s\n", magic)
    fmt.Printf("  Width: %d\n", width)
    fmt.Printf("  Height: %d\n", height)
    fmt.Printf("  MaxVal: %d\n", maxVal)

    // 验证流位置：现在应该指向二进制数据的第一个字节
    // 读取剩余的数据，看是否从 "A" 开始
    remainingBytes, err := io.ReadAll(reader)
    if err != nil {
        log.Fatalf("Error reading remaining bytes: %v", err)
    }
    fmt.Printf("Remaining data (first few bytes): %s\n", string(remainingBytes)) // 应该输出 "ABCDEFGHIJ"
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "testing" // 导入 testing 包
)

// TestFmtBehavior 验证 fmt.Fscanf 在特定条件下的行为
func TestFmtBehavior(t *testing.T) {
    // 使用 io.MultiReader 来确保 r 不会实现 io.RuneScanner 接口，
    // 从而模拟一个不带 UnreadRune 方法的 io.Reader。
    // 数据为 "data  "，其中有两个空格。
    r := io.MultiReader(bytes.NewReader([]byte("data  ")))

    var s string
    var c byte
    // 尝试解析一个字符串和一个字符。
    // 期望 fmt.Fscanf 能够读取 "data" 和第一个空格。
    n, err := fmt.Fscanf(r, "%s%c", &s, &c)

    // 验证 fmt.Fscanf 是否成功解析了两个字段，且没有错误。
    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("scanned string is '%s', expected 'data'", s)
    }
    if c != ' ' {
        t.Errorf("scanned char is '%c', expected ' '", c)
    }

    // 此时，fmt.Fscanf 应该已经读取了 "data" 和一个空格。
    // 如果 %c 占位符的行为是“多读一个字符”，那么输入流中应该还剩一个空格。
    // 尝试读取剩余的数据，验证是否只有一个字节（即第二个空格）被保留。
    remaining := make([]byte, 5) // 足够大的缓冲区
    numRemaining, err := r.Read(remaining)

    if err != nil && err != io.EOF {
        t.Errorf("error reading remaining bytes: %v", err)
    }

    // 断言：应该只剩一个字节（第二个空格）
    if numRemaining != 1 {
        t.Errorf("assertion failed: expected 1 remaining byte, got %d. Remaining: %q", numRemaining, remaining[:numRemaining])
    }
    if numRemaining == 1 && remaining[0] != ' ' {
        t.Errorf("assertion failed: expected remaining byte to be ' ', got '%c'", remaining[0])
    }
}