如何用循环替代Switch检查Go结构体中切片字段的长度？

我现在用Switch语句检查Go语言Things结构体里各个切片字段的长度，但结构体实际有12个字段，导致这个函数又长又重复。我试过用字符串拼接的方式获取字段长度，但拿到的只是字符串本身的长度，用data[value]也不管用，想问问能不能用循环替代Switch实现这个检查逻辑。

相关代码：

type Things struct {
    StreetNames    []string `json:"streetNames"`
    Letters        []string `json:"letters"`
    MaleNames      []string `json:"maleNames"`
}

func CheckCategories(data *Things, filePath string) error {
    errMsg := "list has no values or is a missing category in File: " + filePath
    categories := []string{"street_name", "letter", "male_first_name"}
    for _, value := range categories {
        switch value {
        case "street_name":
            if len(data.StreetNames) == 0 {
                return errors.New("street_name " + errMsg)
            }
        case "letter":
            if len(data.Letters) == 0 {
                return errors.New("letter " + errMsg)
            }
        case "male_first_name":
            if len(data.MaleNames) == 0 {
                return errors.New("male_first_name " + errMsg)
            }
        }
    }
    return nil
}

我尝试的无效代码：

for _, value := range categories {
        if len("data." + value) == 0 {
            return errors.New(value + errMsg)
}

Go是静态类型语言，无法通过字符串直接访问结构体字段，你可以用以下两种方式替代Switch实现循环检查：

方法一：字段映射法 #

建立分类名称到结构体字段的映射，通过函数获取对应切片，循环遍历检查：

import "errors"

type Things struct {
    StreetNames    []string `json:"streetNames"`
    Letters        []string `json:"letters"`
    MaleNames      []string `json:"maleNames"`
    // 补充其他9个字段...
}

func CheckCategories(data *Things, filePath string) error {
    errMsg := "list has no values or is a missing category in File: " + filePath
    // 绑定分类名与对应切片的获取逻辑
    categoryFields := map[string]func(*Things) []string{
        "street_name":     func(t *Things) []string { return t.StreetNames },
        "letter":          func(t *Things) []string { return t.Letters },
        "male_first_name": func(t *Things) []string { return t.MaleNames },
        // 其他分类对应的字段映射...
    }

    for category, getSlice := range categoryFields {
        if len(getSlice(data)) == 0 {
            return errors.New(category + " " + errMsg)
        }
    }
    return nil
}

这种方式逻辑清晰，新增字段时只需在映射中添加一行，相比Switch更易维护。

方法二：反射法（适合大量字段场景） #

利用Go的反射机制，结合自定义结构体Tag自动遍历切片字段：

import (
    "errors"
    "reflect"
)

type Things struct {
    StreetNames    []string `json:"streetNames" check:"street_name"`
    Letters        []string `json:"letters" check:"letter"`
    MaleNames      []string `json:"maleNames" check:"male_first_name"`
    // 其他字段添加对应的check tag...
}

func CheckCategories(data *Things, filePath string) error {
    errMsg := "list has no values or is a missing category in File: " + filePath
    val := reflect.ValueOf(data).Elem() // 获取结构体的反射值
    typ := val.Type()

    for i := 0; i < val.NumField(); i++ {
        field := val.Field(i)
        // 只处理切片类型的字段
        if field.Kind() != reflect.Slice {
            continue
        }
        // 获取自定义的check tag值
        category := typ.Field(i).Tag.Get("check")
        if category == "" {
            continue // 跳过无check tag的字段
        }
        if field.Len() == 0 {
            return errors.New(category + " " + errMsg)
        }
    }
    return nil
}

这种方式无需手动维护字段映射，新增字段时只需添加对应的checkTag即可，适合字段数量多且频繁变动的场景。反射存在微小性能开销，但对于这类检查逻辑几乎可以忽略。

内容的提问来源于stack exchange，提问作者Barry Marples