Go语言中跟踪唯一交易：解决结构体作为Map键的不可比较问题

要统计重复交易，核心是把不可比较的Transaction结构体转换成可比较的唯一标识，替代原结构体作为map的key。以下是几种可行方案：

方案1：生成有序字符串作为key #

由于map的遍历是无序的，直接序列化会导致相同内容的items得到不同字符串，因此需要先对items的键排序，再拼接成唯一字符串。

代码示例： #

import (
    "sort"
    "strings"
    "strconv"
)

type Transaction struct {
    items map[string]int
    date  int
}

// 生成交易的唯一key字符串
func getTransactionKey(t Transaction) string {
    // 提取items的键并排序
    keys := make([]string, 0, len(t.items))
    for k := range t.items {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    
    // 拼接日期和有序的键值对
    var sb strings.Builder
    sb.WriteString(strconv.Itoa(t.date))
    sb.WriteByte('|') // 用分隔符避免日期和内容混淆
    for _, k := range keys {
        sb.WriteString(k)
        sb.WriteByte(':')
        sb.WriteString(strconv.Itoa(t.items[k]))
        sb.WriteByte(',')
    }
    return sb.String()
}

// 使用示例
func main() {
    countMap := make(map[string]int)
    
    t1 := Transaction{
        items: map[string]int{"apples": 2, "bananas": 1},
        date:  20250101,
    }
    t2 := Transaction{
        items: map[string]int{"bananas": 1, "apples": 2}, // 键顺序不同，但内容一致
        date:  20250101,
    }
    
    countMap[getTransactionKey(t1)]++
    countMap[getTransactionKey(t2)]++
    
    // 唯一交易数：len(countMap) → 1
    // 重复交易数：总交易数(2) - 唯一交易数(1) → 1
}

方案2：生成哈希值作为key #

如果交易内容较长，用哈希值（如MD5、SHA1）作为key更节省内存，原理和方案1一致，只是把拼接后的字符串转换成哈希值。

代码示例： #

import (
    "crypto/md5"
    "encoding/hex"
    "sort"
    "strings"
    "strconv"
)

func getTransactionHash(t Transaction) string {
    keys := make([]string, 0, len(t.items))
    for k := range t.items {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    
    var sb strings.Builder
    sb.WriteString(strconv.Itoa(t.date))
    for _, k := range keys {
        sb.WriteString(k)
        sb.WriteString(strconv.Itoa(t.items[k]))
    }
    
    hash := md5.Sum([]byte(sb.String()))
    return hex.EncodeToString(hash[:])
}

// 使用时直接用hash值作为map的key即可

方案3：重构Transaction结构体 #

在创建交易时提前生成可比较的items标识，避免每次统计时重复计算，适合高频统计场景。

代码示例： #

import (
    "sort"
    "strings"
    "strconv"
)

type Transaction struct {
    itemsMap map[string]int
    itemsKey string // 提前生成的有序键值对字符串
    date     int
}

// 构造函数，创建交易时自动生成itemsKey
func NewTransaction(date int, items map[string]int) Transaction {
    keys := make([]string, 0, len(items))
    for k := range items {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    
    var sb strings.Builder
    for _, k := range keys {
        sb.WriteString(k)
        sb.WriteByte(':')
        sb.WriteString(strconv.Itoa(items[k]))
        sb.WriteByte(',')
    }
    
    return Transaction{
        itemsMap: items,
        itemsKey: sb.String(),
        date:     date,
    }
}

// 定义可比较的Key结构体
type TransactionKey struct {
    Date     int
    ItemsKey string
}

// 使用示例
func main() {
    countMap := make(map[TransactionKey]int)
    
    t := NewTransaction(20250101, map[string]int{"apples": 2, "bananas": 1})
    key := TransactionKey{t.date, t.itemsKey}
    countMap[key]++
}

统计逻辑说明 #

• 唯一交易数量：直接取统计map的长度len(countMap)
• 重复交易数量：总交易数减去唯一交易数（totalTransactions - len(countMap)）

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