如何通过反射遍历结构体中的切片结构体并实现比较

需求 #

• 将两个结构体（a、b）分别与基准结构体（full）做字段级对比
• 利用反射遍历所有字段，记录每个字段的匹配状态（Correct_A/Correct_B）和差异度（Distance_A/Distance_B），结果存入Result结构体
• 针对字段World（长度恒为1的结构体切片），需取出切片第一个元素，递归遍历其内部字段完成对比

完整实现代码 #

package main

import (
	"reflect"
)

type Foo struct {
	Hello string
	World []Bar
}

type Bar struct {
	Fish string
}

type Result struct {
	Field string

	Correct_A  bool
	Distance_A int

	Correct_B  bool
	Distance_B int

	Result []Result
}

// compare 判断字段值是否与基准值完全匹配
func (r *Result) compare(base, valA, valB interface{}) {
	r.Correct_A = reflect.DeepEqual(base, valA)
	r.Correct_B = reflect.DeepEqual(base, valB)
}

// lev 计算字符串字段与基准值的编辑距离（非字符串类型返回-1）
func (r *Result) lev(base, valA, valB interface{}) {
	baseStr, ok := base.(string)
	if !ok {
		r.Distance_A = -1
		r.Distance_B = -1
		return
	}

	valAStr, _ := valA.(string)
	valBStr, _ := valB.(string)

	r.Distance_A = editDistance(baseStr, valAStr)
	r.Distance_B = editDistance(baseStr, valBStr)
}

// editDistance 实现Levenshtein编辑距离计算
func editDistance(s, t string) int {
	m, n := len(s), len(t)
	d := make([][]int, m+1)
	for i := range d {
		d[i] = make([]int, n+1)
		d[i][0] = i
	}
	for j := range d[0] {
		d[0][j] = j
	}

	for j := 1; j <= n; j++ {
		for i := 1; i <= m; i++ {
			if s[i-1] == t[j-1] {
				d[i][j] = d[i-1][j-1]
			} else {
				d[i][j] = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+1)
			}
		}
	}
	return d[m][n]
}

func min(a, b, c int) int {
	minVal := a
	if b < minVal {
		minVal = b
	}
	if c < minVal {
		minVal = c
	}
	return minVal
}

// compareStructs 递归对比结构体及嵌套字段
func compareStructs(full, a, b interface{}) []Result {
	var result []Result

	rfxF := reflect.ValueOf(full)
	rfxA := reflect.ValueOf(a)
	rfxB := reflect.ValueOf(b)

	typeF := rfxF.Type()

	for i := 0; i < rfxF.NumField(); i++ {
		field := typeF.Field(i)
		tmpRes := Result{Field: field.Name}

		fieldF := rfxF.Field(i)
		fieldA := rfxA.FieldByName(field.Name)
		fieldB := rfxB.FieldByName(field.Name)

		if field.Type.Kind() != reflect.Slice {
			// 处理普通字段
			tmpRes.compare(fieldF.Interface(), fieldA.Interface(), fieldB.Interface())
			tmpRes.lev(fieldF.Interface(), fieldA.Interface(), fieldB.Interface())
			result = append(result, tmpRes)
		} else if field.Name == "World" {
			// 处理World切片（场景约定长度为1）
			if fieldF.Len() == 0 {
				result = append(result, tmpRes)
				continue
			}
			// 取出切片首个元素递归对比
			elemF := fieldF.Index(0).Interface()
			elemA := fieldA.Index(0).Interface()
			elemB := fieldB.Index(0).Interface()

			tmpRes.Result = compareStructs(elemF, elemA, elemB)
			result = append(result, tmpRes)
		}
	}

	return result
}

func main() {
	// 示例数据
	full := Foo{Hello: "hello", World: []Bar{{Fish: "cod"}}}
	a := Foo{Hello: "hell", World: []Bar{{Fish: "cod"}}}
	b := Foo{Hello: "hello", World: []Bar{{Fish: "bass"}}}

	// 执行对比
	comparisonResult := compareStructs(full, a, b)
	// 可根据需求打印或处理comparisonResult
}

核心实现要点 #

• 反射遍历：通过reflect包获取结构体的字段信息和值，实现通用的字段遍历逻辑
• 递归嵌套处理：针对World切片，取出第一个元素后递归调用对比函数，支持嵌套结构体的深度对比
• 差异量化：用reflect.DeepEqual判断完全匹配，用编辑距离量化字符串字段的差异程度
• 结果层级存储：Result结构体通过自身切片字段存储嵌套对比结果，保持结构一致性

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