Go 语言中高效读取标准输入数字的完整指南

在编程竞赛等高性能场景下，`fmt.scanf` 读取大量整数效率极低；本文详解其性能瓶颈，并提供基于 `bufio.scanner`、`bufio.reader` 和 `strconv` 的高效替代方案，兼顾安全性、通用性与可扩展性。

fmt.Scanf 在高频输入场景下表现糟糕，根本原因在于其设计目标是格式灵活解析（支持复杂格式字符串、多类型混合扫描），而非吞吐优化：它内部依赖 fmt.Fscanf，需反复进行格式解析、类型推断、内存分配及反射调用，导致单次调用开销高；当处理 $10^5$ 级别整数时，累积开销可达秒级（实测常超 2 秒），远逊于 Python 的 sys.stdin.readline() + int() 组合。

真正高效的输入应遵循三大原则：预分配缓冲、避免格式解析、使用无分配转换。推荐以下三种生产级方案，按适用场景递进：

✅ 方案一：bufio.Scanner（最常用，安全简洁）

适用于以行为单位的整数输入（如每行一个数），自动处理换行、空格分隔，且默认缓冲 64KB，性能优异：

package main

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

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    var nums []int64

    for scanner.Scan() {
        line := scanner.Text()
        if line == "" {
            continue // 跳过空行
        }
        n, err := strconv.ParseInt(line, 10, 64)
        if err != nil {
            fmt.Fprintf(os.Stderr, "parse error: %v\n", err)
            continue
        }
        nums = append(nums, n)
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }

    fmt.Printf("Read %d numbers\n", len(nums))
}

⚠️ 注意：scanner.Text() 返回的是不带换行符的字符串副本，若需极致零拷贝，应改用 scanner.Bytes() 配合 strconv.ParseInt(..., 10, 64) 直接解析字节切片（见方案三）。

✅ 方案二：bufio.Reader（精准控制，支持多值/混合类型）

当一行含多个数字（如 "123 456 789"）或需混合读取 int/uint64/float64 时，bufio.Reader 提供更底层的控制能力：

简篇AI排版

AI排版工具，上传图文素材，秒出专业效果！

下载

package main

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

func main() {
    reader := bufio.NewReader(os.Stdin)
    var nums []int64

    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == bufio.ErrBufferFull {
                // 处理超长行（可扩展逻辑）
                continue
            }
            break // EOF or real error
        }

        fields := strings.Fields(line) // 按空白分割
        for _, s := range fields {
            if n, err := strconv.ParseInt(s, 10, 64); err == nil {
                nums = append(nums, n)
            }
        }
    }

    fmt.Printf("Total: %d numbers\n", len(nums))
}

✅ 方案三：ioutil.ReadAll + strconv（最大吞吐，适合离线批量）

当输入完全可控（如本地测试文件、管道输入），且数据量极大（$10^6$+）时，一次性读入全部字节再批量解析，可逼近理论 I/O 上限：

package main

import (
    "fmt"
    "io"
    "os"
    "strconv"
    "strings"
)

func readAllInts() ([]int64, error) {
    data, err := io.ReadAll(os.Stdin)
    if err != nil {
        return nil, err
    }

    // 去除末尾可能的换行/空格，按空白分割
    s := strings.TrimSpace(string(data))
    if s == "" {
        return []int64{}, nil
    }

    fields := strings.Fields(s)
    nums := make([]int64, 0, len(fields))
    for _, field := range fields {
        n, err := strconv.ParseInt(field, 10, 64)
        if err != nil {
            return nil, fmt.Errorf("invalid int in input: %q", field)
        }
        nums = append(nums, n)
    }
    return nums, nil
}

func main() {
    nums, err := readAllInts()
    if err != nil {
        panic(err)
    }
    fmt.Printf("Parsed %d integers\n", len(nums))
}

? 关键优化点：

• 使用 strings.Fields 替代正则，避免编译与匹配开销；
• 预分配 nums 切片容量（make(..., 0, len(fields))）减少动态扩容；
• strconv.ParseInt 比 fmt.Sscanf 快 5–10 倍，且无内存分配（ParseInt 内部为纯字节遍历）。

? 总结与选型建议

切记：永远避免在循环中使用 fmt.Scanf 读取大量数据。用对工具，Go 完全能在编程竞赛中媲美甚至超越 C++/Python 的输入性能。