如何以Go语言惯用方式合并两个相似的查询参数解析函数？

你的两个函数核心逻辑高度重复，仅在最终调用的解析函数（strconv.ParseInt/strconv.ParseUint）和返回值类型上有区别。在Go 1.18及以上版本中，泛型是最符合Go风格的简洁合并方式，既能消除重复代码，又能保证类型安全。

实现步骤 #

1. 定义泛型约束
   首先定义一个仅包含int64和uint64的类型约束，限定泛型函数的参数类型范围：

type Integer interface {
    int64 | uint64
}

2. 编写泛型合并函数
   将公共的参数校验逻辑复用，内部根据泛型类型自动选择对应的解析函数：

import (
    "fmt"
    "net/url"
    "strconv"
)

func ParseQueryParam[T Integer](name string, base int, bits int, values *url.Values) (T, error) {
    param := (*values)[name]

    // 公共参数校验逻辑
    if len(param) < 1 {
        return 0, fmt.Errorf("missing parameter %s", name)
    }
    if len(param) > 1 {
        return 0, fmt.Errorf("duplicate parameter %s", name)
    }
    strVal := param[0]

    var result T
    // 根据泛型类型选择解析逻辑
    switch any(result).(type) {
    case int64:
        v, err := strconv.ParseInt(strVal, base, bits)
        if err != nil {
            return 0, fmt.Errorf("bad value for '%s' (%w)", name, err)
        }
        result = T(v)
    case uint64:
        v, err := strconv.ParseUint(strVal, base, bits)
        if err != nil {
            return 0, fmt.Errorf("bad value for '%s' (%w)", name, err)
        }
        result = T(v)
    }

    return result, nil
}

调用示例 #

调用时只需指定泛型类型，即可分别解析有符号或无符号整数：

func main() {
    values := url.Values{
        "unsigned_id": {"12345"},
        "signed_count": {"-9876"},
    }

    // 解析无符号整数
    unsignedVal, err := ParseQueryParam[uint64]("unsigned_id", 10, 64, &values)
    if err != nil {
        panic(err)
    }
    fmt.Println("Unsigned value:", unsignedVal)

    // 解析有符号整数
    signedVal, err := ParseQueryParam[int64]("signed_count", 10, 64, &values)
    if err != nil {
        panic(err)
    }
    fmt.Println("Signed value:", signedVal)
}

方案优势 #

• 消除重复代码：公共的参数校验逻辑完全复用，仅保留差异化的解析逻辑
• 类型安全：通过泛型约束限定输入输出类型，避免了interface{}带来的类型断言繁琐与风险
• 符合Go风格：错误处理使用%w包装原始错误，保留错误链，遵循Go错误处理最佳实践
• 调用直观：调用方只需指定泛型类型，即可清晰区分解析目标类型

关于接口方案的说明 #

如果尝试用接口实现，返回值需使用interface{}，调用方必须手动进行类型断言，不仅代码繁琐，还会丢失类型安全，不符合Go的简洁实用原则，因此不推荐。

内容的提问来源于stack exchange，提问作者Charlie Skilbeck