登录
推荐 文章 Go 技术 课程 下载 专题 AI
首页 >  Golang >  Go教程

Go text/scanner.Scanner.Peek 怎样预读下一个字符而不消费

来源:17golang原创

时间:2026-11-17 07:39:43 368浏览 收藏

我在给配置表达式加一个很小的前置判断时,最容易写出的一段逻辑是“先 Scan,发现不是目标字符,再想办法把它放回去”。这条路不仅麻烦,还会把 token 识别、位置记录和错误处理搅在一起。text/scanner.Scanner.Peek 正好解决了这个问题:它返回当前位置的下一个 Unicode 字符,但不会推进扫描器;确认要处理后,再交给 Scan 或 Next 消费即可。

官方地址:https://pkg.go.dev/text/scanner#Scanner.Peek

迁移时记住一条边界:Peek 是观察动作,不会更新扫描位置;Scan 读取 token 或字符,Next 读取单个 Unicode 字符并推进。到达输入末尾时,Peek 返回 scanner.EOF,不要把它当成普通字符继续处理。

先把 Scanner 的当前位置想清楚

Scanner 以 io.Reader 为输入,默认按 UTF-8 文本扫描。初始化后,扫描器内部有一个当前位置。Peek 看到的是“从这个位置开始的下一个 Unicode 字符”,不是最近一次 token 的完整文本,也不是已经消费过的字符。

package main

import (
    "fmt"
    "strings"
    "text/scanner"
)

func main() {
    var s scanner.Scanner
    // 用内存文本初始化扫描器,示例只关注当前位置和预读行为。
    s.Init(strings.NewReader("name = 中"))

    // Peek 只查看当前位置的字符,不让扫描器前进。
    next := s.Peek()
    fmt.Printf("next=%q position=%s\n", next, s.Pos())
}

这里的重点不是打印格式,而是调用时机:初始化后先观察,真正的 token 读取仍由后续的扫描方法负责。若你的代码需要记录 token 起点,应在 Scan 后使用 s.Position;若要看当前位置,可使用 s.Pos()。

Peek 为什么不会消费字符

最小用法是连续调用两次 Peek,再调用一次 Next。两次预读应得到相同字符,Next 才会推进到下一个字符。这个顺序很适合做分支:先判断是不是分隔符、括号或自定义前缀,只有确认属于当前语法时才消费。

package main

import (
    "fmt"
    "strings"
    "text/scanner"
)

func main() {
    var s scanner.Scanner
    // 中间包含多字节 Unicode 字符,用来说明 Peek 返回的是 rune。
    s.Init(strings.NewReader("中=1"))

    first := s.Peek()
    second := s.Peek()
    fmt.Printf("peek1=%q peek2=%q same=%t\n", first, second, first == second)

    // Next 才消费一个 Unicode 字符;错误由 Scanner 按文档回调或报告。
    consumed := s.Next()
    fmt.Printf("consumed=%q next=%q\n", consumed, s.Peek())
}
Scanner.Peek 观察字符而不推进,Scan 或 Next 才消费字符的调用流程
图1:Scanner.Peek 只观察当前位置,Scan 或 Next 才把扫描位置向前推进;这是静态结构示意图。

如果要读取完整 token,优先用 Scan;如果你的语法只需要逐个字符判断,才用 Next。不要为了“看一眼”而调用 Scan,再额外设计回退状态。

Peek 和 Scan、Next 应该怎么分工

调用用途是否推进结果
Peek()预读下一个 Unicode 字符否rune,末尾为 scanner.EOF
Next()读取单个 Unicode 字符是rune,末尾为 scanner.EOF
Scan()读取下一个 token 或字符是token 常量、Unicode 字符或 scanner.EOF

我实际迁移时采用的判断是:需要知道“下一个字符是什么”就先 Peek;需要得到一个完整 token 就直接 Scan;需要逐字符处理且确认要前进时用 Next。这样每次推进都只有一个明确的调用点。

到达输入末尾时怎样处理 EOF

Peek 在扫描器位置已经处于源文本末尾时返回 scanner.EOF。它不是有效的 Unicode 字符,也不是可以继续交给业务解析的分隔符。循环中应先判断 EOF,再决定是否消费或结束。

package main

import (
    "fmt"
    "strings"
    "text/scanner"
)

func main() {
    var s scanner.Scanner
    // 逐字符消费输入,Peek 用来判断是否还有字符。
    s.Init(strings.NewReader("ab"))

    for {
        next := s.Peek()
        if next == scanner.EOF {
            // 到达源末尾后退出,避免把 EOF 当成业务字符。
            break
        }
        fmt.Printf("lookahead=%q\n", next)
        // 已确认要处理当前字符,再调用 Next 推进。
        _ = s.Next()
    }
}
Scanner.Peek 在中间字符、最后字符和输入末尾返回值的边界对照图
图2:Scanner 在输入末尾返回 scanner.EOF;图中对照了字符位置与结束位置的判断顺序,是静态边界说明图。

有一个容易忽略的细节:在最后一个字符仍未消费时,Peek 返回的是这个字符;消费它之后,下一次 Peek 才会看到 scanner.EOF。所以“最后一个字符”和“输入末尾”是两个不同状态。

把先消费再回退的旧写法迁移掉

如果旧代码先调用 Scan,再通过变量缓存、手动拼接或额外状态模拟“放回去”,迁移可以按三个动作完成:

  1. 把只用于判断的第一次 Scan 换成 Peek。
  2. 判断通过后,在同一分支中调用 Scan 或 Next 完成消费。
  3. 判断失败时不要推进扫描器,直接进入其他分支或返回错误。
package main

import (
    "fmt"
    "strings"
    "text/scanner"
)

func readOptionalEqual(s *scanner.Scanner) bool {
    // 先预读,非等号时保持扫描位置不变,交给调用方处理。
    if s.Peek() != '=' {
        return false
    }
    // 只有确认目标字符后才消费它。
    _ = s.Next()
    return true
}

func main() {
    var s scanner.Scanner
    // 示例把等号当作可选语法符号,演示失败分支不会偷走字符。
    s.Init(strings.NewReader("=value"))
    fmt.Println(readOptionalEqual(&s), s.Peek())
}

这个迁移并不意味着所有解析都要改成逐字符处理。复杂 token 仍然交给 Scan,Peek 只负责在消费前提供一个轻量 lookahead。把观察和消费拆开,通常比维护回退缓冲更容易读,也更不容易让位置信息失真。

几个容易踩到的边界

  • 不要把 Peek 当成 Scan。Peek 不会更新扫描位置,也不会产生最近 token 的 TokenText。
  • 不要把 EOF 当作字符。先判断 scanner.EOF,再进入业务分支。
  • 需要完整 token 时别手工拼接。让 Scan 依据 Mode 识别 token,手工字符逻辑只处理确实需要 lookahead 的语法。
  • 区分 Pos 和 Position。Pos 表示最近一次 Next 或 Scan 后的位置;Position 是最近扫描 token 的起始信息,二者不是同一时刻。

相关问题

连续调用 Peek 会不会跳过字符?

不会。它返回当前位置的下一个 Unicode 字符而不推进,因此连续预读在没有其他消费调用时会得到同一个字符。

Peek 之后应该调用 Scan 还是 Next?

要消费完整 token 用 Scan,只消费一个 Unicode 字符用 Next。选择取决于后续逻辑的粒度。

为什么最后一个字符后才出现 EOF?

最后一个字符仍在当前位置时,Peek 当然先返回这个字符;调用 Next 或 Scan 消费它后,扫描位置才到达源末尾,下一次预读才返回 scanner.EOF。

这次迁移的结果可以压缩成一句话:Peek 负责看,Scan/Next 负责走;先判断 EOF,再决定是否消费。

声明:本文转载于:17golang原创 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>