what
ba0fd4b3bc
Keys() 的 struct 分支早就是原生的了, map 分支一直委托给 refx, 而那边用的是
fmt.Sprint(k.Interface()) —— 要先把 key 装箱成 interface 再走一遍格式化。
对字符串键完全没必要。
Keys() 3 个字符串键的 map 193.3ns / 9 allocs -> 119.7ns / 5 allocs 1.61x
非字符串键仍旧走 fmt.Sprint: k.String() 对非字符串 Value 返回的是
"<int Value>" 这种占位串而不是键本身, 无脑替换会静默给出错误的键名。
按 m.Type().Key().Kind() 分支处理。
顺带把 normalize() 提到开头, 这样经指针或 interface 拿到的 map/struct 也能
走原生分支, 而不是掉进 slow()。
测试期间发现并修掉一处自己引入的差异: nil map 上旧实现返回 []string{},
我最初加的 IsNil 提前返回给出的是 nil。两者在 reflect.DeepEqual 和 JSON
序列化(`[]` vs `null`)上不同。MapKeys() 对 nil map 本来就返回空切片而不是
panic, 那个提前返回是多余的。
测试覆盖 11 种输入与旧实现对拍(string/具名 string/int/int64/float/bool 键、
空 map、nil map、struct、切片、嵌套 map), 外加经路径取到的 map、
interface 包着的 map、指针指向的 map, 以及非字符串键必须是真实键值的断言。
map 迭代顺序随机, 比较前排序。
88 lines
2.7 KiB
Go
88 lines
2.7 KiB
Go
package reflux
|
|
|
|
import (
|
|
"reflect"
|
|
"sort"
|
|
"testing"
|
|
)
|
|
|
|
// Keys() 的 map 分支现在按键类型分支: 字符串键直接取, 其余仍走 fmt.Sprint。
|
|
// 这一组守的是"分支之后行为不变" —— 尤其是非字符串键不能退化成
|
|
// k.String() 的 "<int Value>" 占位串。
|
|
|
|
type keyStr string
|
|
|
|
func TestKeysMatchesLegacy(t *testing.T) {
|
|
type inner struct{ A, B string }
|
|
|
|
cases := []struct {
|
|
name string
|
|
val func() any
|
|
}{
|
|
{"string 键 map", func() any { return &map[string]int{"b": 2, "a": 1, "c": 3} }},
|
|
{"具名 string 键 map", func() any { return &map[keyStr]int{"b": 2, "a": 1} }},
|
|
{"int 键 map", func() any { return &map[int]string{2: "b", 1: "a", 10: "j"} }},
|
|
{"int64 键 map", func() any { return &map[int64]string{7: "x"} }},
|
|
{"float 键 map", func() any { return &map[float64]string{1.5: "x"} }},
|
|
{"bool 键 map", func() any { return &map[bool]string{true: "t", false: "f"} }},
|
|
{"空 map", func() any { return &map[string]int{} }},
|
|
{"nil map", func() any { var m map[string]int; return &m }},
|
|
{"struct", func() any { return &inner{} }},
|
|
{"切片(两边都不支持)", func() any { return &[]string{"a"} }},
|
|
{"map 里的 map", func() any { return &map[string]any{"sub": map[string]any{"x": 1}} }},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
want := newLegacy(c.val()).Keys()
|
|
got := New(c.val()).Keys()
|
|
// map 迭代顺序随机, 比较前排序
|
|
sort.Strings(want)
|
|
sort.Strings(got)
|
|
if !reflect.DeepEqual(want, got) {
|
|
t.Fatalf("Keys() 不一致\n 旧 = %#v\n 新 = %#v", want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// 经路径取到的 map / interface 包着的 map 也要正确
|
|
func TestKeysThroughPath(t *testing.T) {
|
|
doc := &struct {
|
|
Meta map[string]string
|
|
Any any
|
|
Ptr *map[string]string
|
|
}{
|
|
Meta: map[string]string{"k1": "v", "k2": "v"},
|
|
Any: map[string]string{"a1": "v"},
|
|
}
|
|
m := map[string]string{"p1": "v"}
|
|
doc.Ptr = &m
|
|
|
|
r, l := New(doc), newLegacy(doc)
|
|
for _, p := range []string{"Meta", "Any", "Ptr"} {
|
|
t.Run(p, func(t *testing.T) {
|
|
want, got := l.Get(p).Keys(), r.Get(p).Keys()
|
|
sort.Strings(want)
|
|
sort.Strings(got)
|
|
if !reflect.DeepEqual(want, got) {
|
|
t.Fatalf("Get(%q).Keys() 不一致\n 旧 = %#v\n 新 = %#v", p, want, got)
|
|
}
|
|
if len(got) == 0 {
|
|
t.Fatalf("Get(%q).Keys() 不该为空", p)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// 非字符串键必须是键本身的值, 不能是 "<int Value>" 这种占位串
|
|
func TestKeysNonStringKeysAreReal(t *testing.T) {
|
|
got := New(&map[int]string{42: "x"}).Keys()
|
|
if len(got) != 1 || got[0] != "42" {
|
|
t.Fatalf("int 键的 Keys() = %#v, 期望 [\"42\"]", got)
|
|
}
|
|
if got := New(&map[bool]string{true: "x"}).Keys(); len(got) != 1 || got[0] != "true" {
|
|
t.Fatalf("bool 键的 Keys() = %#v, 期望 [\"true\"]", got)
|
|
}
|
|
}
|