Go slices.Compact 怎样保留错误信息

如果错误流里连续出现同一类问题，想压缩日志又不丢掉第一条错误的上下文，可以用 slices.CompactFunc；如果元素本身可以按 Go 的 == 比较，也可以用 slices.Compact。关键是先分清“相邻重复”和“整个序列重复”：Compact 只删除连续重复，不会跨过其他错误寻找同类项。

保留错误信息的稳妥写法，是把错误码、展示文本和原始 error 放在一条结构化记录里，用 CompactFunc 只比较稳定的业务字段，并让函数保留每段的第一条记录。需要全局去重时，改用 map，不要把 Compact 当成集合去重。

先看清 slices.Compact 处理的是什么

slices.Compact 的签名要求元素类型满足 comparable。它在原切片上移动元素，返回缩短后的切片，并把新长度到旧长度之间的元素置为零值。下面这个序列中，两个“超时”和两个“参数错误”各自相邻，因此每段只留下第一项；最后一个“超时”不相邻，不会被删除。

package main

import (
	"fmt"
	"slices"
)

func main() {
	// 只有相邻的相同字符串会被压缩，最后一个“超时”与前面的项不相邻。
	errs := []string{"超时", "超时", "参数错误", "参数错误", "超时"}
	errs = slices.Compact(errs)

	// 重新接住返回值，否则仍会按旧长度访问切片。
	fmt.Println(errs) // [超时 参数错误 超时]
}

这段代码适合元素已经有明确相等语义的场景，例如连续重复的状态码字符串。它不回答“错误信息是否语义相同”，只回答“相邻两个元素是否可以按 == 判断为相等”。

为什么 []error 直接 Compact 可能保留得太多

error 是接口。接口值的比较会同时考虑动态类型和动态值，而不是自动比较 Error() 返回的文本。常见的 errors.New("超时") 每调用一次都会得到新的错误实例，所以即使文本相同，直接比较也通常不相等。这样一来，下面的连续错误不会按文字被压缩。

package main

import (
	"errors"
	"fmt"
	"slices"
)

func main() {
	// 每次 errors.New 都创建一个新的错误实例，文本相同不代表实例相同。
	errList := []error{
		errors.New("数据库超时"),
		errors.New("数据库超时"),
	}

	// error 接口本身可以作为元素类型，但比较结果不是按 Error() 文本决定的。
	errList = slices.Compact(errList)
	fmt.Println(len(errList)) // 通常仍为 2
}

还有一个更隐蔽的边界：接口动态值如果是不可比较类型，运行时比较接口值可能触发 panic。因此，日志压缩不应该把“接口能否比较”和“业务上是否同一种错误”混为一谈。若错误类型本身有稳定的哨兵值，可以用 errors.Is 做语义判断；但这已经不是 Compact 默认的 == 规则了。

用 CompactFunc 按错误码保留第一条原始记录

实际日志通常既要保存错误对象，也要保存错误码、用户可读文本和请求上下文。可以定义一条结构化记录，让比较函数只检查稳定字段；压缩时保留下来的第一项仍带着它最早的原始 error，而不是重新创建一个只有文本的错误。

package main

import (
	"errors"
	"fmt"
	"slices"
)

type errorItem struct {
	Code    string
	Message string
	Cause   error
}

func main() {
	errList := []errorItem{
		{Code: "DB_TIMEOUT", Message: "数据库超时", Cause: errors.New("dial timeout")},
		{Code: "DB_TIMEOUT", Message: "数据库超时", Cause: errors.New("read timeout")},
		{Code: "BAD_INPUT", Message: "参数错误", Cause: errors.New("page is negative")},
		{Code: "BAD_INPUT", Message: "参数错误", Cause: errors.New("limit is zero")},
	}

	// 只按业务字段判断相邻记录是否同类，保留每段第一条 Cause。
	errList = slices.CompactFunc(errList, func(a, b errorItem) bool {
		return a.Code == b.Code && a.Message == b.Message
	})

	for _, item := range errList {
		// 原始 Cause 仍在第一条记录中，可继续用于日志或 errors.Is。
		fmt.Printf("%s: %s (%v)\n", item.Code, item.Message, item.Cause)
	}
}

这个版本保留的是每个连续错误段的第一条原因：第一条数据库超时中的 dial timeout 会留下，第二条的 read timeout 会被压缩掉。如果两条错误码相同但原因必须全部审计，就不应该删除它们，可以把原因追加到一个聚合字段，或者完全不做压缩。

需要跨位置去重时，改用 map

CompactFunc 仍然只比较相邻元素。若错误流是“超时、参数错误、超时”，而产品要求同一错误码全程只出现一次，那么应该维护已见集合。这样可以保留第一次出现的完整记录，也能明确表达“全局去重”的业务规则。

package main

import "fmt"

type errorItem struct {
	Code    string
	Message string
	Cause   error
}

func uniqueByCode(items []errorItem) []errorItem {
	// seen 只记录已经输出过的错误码，避免把非相邻重复误交给 Compact。
	seen := make(map[string]struct{}, len(items))
	result := make([]errorItem, 0, len(items))
	for _, item := range items {
		if _, exists := seen[item.Code]; exists {
			// 忽略后来的同码记录，但第一条的原始 Cause 已经保留在 result 中。
			continue
		}
		seen[item.Code] = struct{}{}
		result = append(result, item)
	}
	return result
}

func main() {
	// 这个调用示例强调全局去重，而不是只压缩连续重复。
	items := []errorItem{{Code: "TIMEOUT"}, {Code: "BAD_INPUT"}, {Code: "TIMEOUT"}}
	fmt.Println(len(uniqueByCode(items))) // 2
}

map 方案的代价是需要额外的集合空间，而且“相同”的键必须自己定义。按错误码去重适合告警摘要；按错误码加租户、接口或资源 ID 去重，才更接近多租户服务中的实际需求。

采用前要确认三个边界

还要记住，Compact 会原地改写底层数组。若旧切片的其他引用仍需要看到原始顺序，先用 slices.Clone 复制，再在副本上压缩；若只是把结果交给下一层处理，直接接住返回值即可。

常见问题

slices.Compact 会删除所有重复错误吗？

不会。它只删除连续相等的元素，不相邻的重复会保留。全局去重要使用 map 或其他显式集合。

为什么两个错误的文字一样，Compact 仍然不压缩？

因为错误接口比较的是动态类型和值，不是自动比较 Error() 的结果。若业务上文字相同就算同类，应在 CompactFunc 中明确写出比较规则。

怎样既压缩日志又不丢掉具体原因？

把错误码、展示文本、原始 error 和必要上下文放在同一条结构化记录中，用 CompactFunc 比较前两个稳定字段，保留每段第一条；如果每个原因都必须留档，就不要删除，改为聚合。

最终可以把选择压缩成一句话：能接受 Go 的直接相等规则就用 slices.Compact；需要业务相等规则就用 slices.CompactFunc；需要跨位置去重就用 map；需要完整审计就保留全部记录。这样“保留错误信息”不是依赖函数的隐含行为，而是由数据结构和去重规则共同保证。