Go maps.Keys 怎样遍历映射键并保持可排序结果

我在把一组配置项写入调试日志时遇到过一个很容易误判的问题：同一个 map，连续输出两次的键顺序可能不同。这个现象不是 maps.Keys 失效，而是 map 本来就不承诺迭代顺序。真正需要稳定结果时，应当先取得键序列，再明确地排序。

Go 1.23 及以上可以用 maps.Keys(m) 遍历键；需要可重复的展示、日志、测试或文件输出时，直接使用 slices.Sorted(maps.Keys(m))。如果键类型不能用默认的有序比较，再改用 slices.SortedFunc。

官方地址：https://pkg.go.dev/maps

先判断你要的是遍历，还是稳定顺序

maps.Keys 解决的是“把 map 的键作为序列提供出来”，不是“给键排好序”。官方文档明确说明，返回的迭代顺序未指定，也不保证两次调用相同。因此下面的写法适合做一次性处理，不适合拿来生成需要稳定比较的文本。

package main

import (
	"fmt"
	"maps"
)

func main() {
	prices := map[string]int{"go": 20, "redis": 30, "mysql": 40}

	// 这里只关心把每个键访问一次，不把输出顺序当作协议的一部分。
	for key := range maps.Keys(prices) {
		fmt.Println(key, prices[key])
	}
}

如果这段代码用于排查日志，看到顺序变化时不要先怀疑 map 内容被修改。先看调用方是否把“遍历顺序”误当成“排序结果”。

用 maps.Keys 得到可 range 的键序列

从类型上看，maps.Keys 返回的是 iter.Seq[K]。它本质上是一个把元素交给 yield 回调的迭代器，所以可以直接写在 Go 的 range 右侧。这样做的好处是调用方不需要暴露 map 的内部遍历细节，也不必先手写一个临时收集函数。

package main

import (
	"fmt"
	"maps"
)

func main() {
	config := map[string]string{"region": "cn", "mode": "safe"}

	// range 会消费键迭代器；这里的顺序仍然没有排序承诺。
	for key := range maps.Keys(config) {
		fmt.Printf("%s=%s\\n", key, config[key])
	}
}

这个入口适合“全部访问、顺序无所谓”的任务，例如统计键数量、把键交给另一个处理函数，或者在找到目标后提前停止。若结果会进入快照测试、缓存键、配置文件或用户可见页面，就应该继续走排序分支。

需要稳定结果时使用 slices.Sorted

对于字符串、整数等支持默认有序比较的键，最短也最清楚的写法是：

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	prices := map[string]int{"go": 20, "redis": 30, "mysql": 40}

	// Sorted 会消费键序列并返回新的升序切片，不改变 prices。
	sortedKeys := slices.Sorted(maps.Keys(prices))
	for _, key := range sortedKeys {
		fmt.Printf("%s=%d\\n", key, prices[key])
	}
}

slices.Sorted 把迭代器收集成切片并按默认比较规则排序。对 string 键，结果是 Go 字符串的字典序；对整数键，结果是数值升序。原 map 仍然是 map，不能因为拿到了排序后的切片就认为以后对 map 的 range 也会有同样顺序。

为什么 map 能用这个键，却不一定能直接排序

这里有两个容易混淆的约束：

• map 的键要求是 comparable，这是为了支持查找和哈希。
• slices.Sorted 要求元素满足 cmp.Ordered，还需要定义小于、大于这样的默认顺序。

所以结构体键只要字段可比较，就可能合法地作为 map 键，但它没有一个自动适用于所有业务的默认排序规则。遇到这类键时，不要为了通过编译随意把结构体转成字符串；应该把排序意图写进比较函数。

结构体键用 slices.SortedFunc 明确排序意图

例如路由键同时包含方法和路径，可以先按方法，再按路径排序：

package main

import (
	"fmt"
	"maps"
	"slices"
)

type Route struct {
	Method string
	Path   string
}

func main() {
	routes := map[Route]int{
		{Method: "POST", Path: "/users"}: 201,
		{Method: "GET", Path: "/users"}:  200,
	}

	// 先按 Method 排序；相同 Method 再按 Path 排序，结果规则可复查。
	sortedRoutes := slices.SortedFunc(maps.Keys(routes), func(a, b Route) int {
		if a.Method != b.Method {
			if a.Method  b.Path {
			return 1
		}
		return 0
	})

	for _, route := range sortedRoutes {
		fmt.Println(route.Method, route.Path, routes[route])
	}
}

比较函数返回负数、零或正数，分别表示前者排在后面、相等或排在前面。重点不是把比较器写得复杂，而是让“同一批数据为什么这样排列”成为代码中可读、可修改的规则。

调试时按这份清单排查

1. 先看版本：maps.Keys 与 iter.Seq 属于 Go 1.23 引入的迭代器生态；旧项目不能只复制新写法，要先确认工具链。
2. 再看用途：一次性访问可以直接 range maps.Keys(m)；日志、测试、导出和协议字段通常需要明确排序。
3. 再看键类型：字符串和整数可直接交给 slices.Sorted；结构体或其他非有序键应提供 slices.SortedFunc。
4. 最后看数据一致性：排序只决定键切片的顺序，不会复制或排序 map 本身；读取值时仍应使用排序后的键回查原 map。

我个人更倾向于把 sortedKeys 命名保留下来，而不是在多处重复调用 maps.Keys。这样一眼就能看出稳定顺序只在输出边界建立，内部 map 仍然按它自己的数据结构工作。

常见问题

maps.Keys 会返回一个已经排好序的切片吗？

不会。它返回 iter.Seq[K]，顺序未指定；要切片并排序，应使用 slices.Sorted(maps.Keys(m))。

排序后的键切片会改变原 map 吗？

不会。排序结果是独立的键切片，原 map 的键值关系不因排序改变。

为什么 map[Route] 可以定义，但 slices.Sorted 不能直接用？

map 只需要键可比较和可哈希；默认排序还需要一个有序关系。对 Route 这类业务结构，应使用 slices.SortedFunc 把排序字段写明白。

只想按 map 的值排序怎么办？

maps.Keys 只产出键。可以先收集键，再在比较函数中通过 map 回查值，或构造包含键和值的切片后按业务字段排序；不要期待 map 自己保存顺序。

总结一下：maps.Keys 负责提供键序列，range 负责访问它，slices.Sorted 或 slices.SortedFunc 负责把“稳定顺序”这件事明确下来。调试输出一旦需要可复现，就不要把 map 的自然遍历顺序当成契约。