Go语言中如何重构IntSet与StringSet的公共方法以消除代码重复？

这确实是Go开发中很典型的代码重复场景——当你有多个逻辑一致但元素类型不同的集合时，重复实现相同方法不仅冗余，还增加了维护成本。针对你的需求，Go 1.18及以上版本的泛型特性是最完美的解决方案：它既可以让你复用核心方法逻辑，又能保持方法与集合类型的绑定关系，完全避开了interface{}带来的类型安全问题，也不用纠结组合模式中基结构体无法访问子结构私有成员的困扰。

重构思路 #

1. 定义一个泛型集合类型，用comparable约束保证元素可以作为map的key（因为你的集合底层是map）。
2. 为这个泛型集合实现通用的Add、AddRange、Contains、ContainsAny、Length方法——这些逻辑只需要写一次。
3. 基于泛型集合定义你的IntSet和StringSet具体类型，它们会自动继承泛型集合的所有方法。
4. 保留各自特有的方法（比如Stringify），因为这些方法的逻辑和元素类型强相关。

重构后的完整代码 #

package main

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

// 泛型集合类型，T必须是可比较类型（满足map key的要求）
type Set[T comparable] map[T]bool

// 泛型构造函数：从切片创建Set
func NewSet[T comparable](vs []T) Set[T] {
	s := Set[T]{}
	s.AddRange(vs)
	return s
}

// --- 以下是泛型集合的通用方法 ---
func (s Set[T]) Add(v T) bool {
	_, found := s[v]
	s[v] = true
	return !found
}

func (s Set[T]) AddRange(vs []T) {
	for _, v := range vs {
		s[v] = true
	}
}

func (s Set[T]) Contains(v T) bool {
	_, found := s[v]
	return found
}

func (s Set[T]) ContainsAny(vs []T) bool {
	for _, v := range vs {
		if _, found := s[v]; found {
			return true
		}
	}
	return false
}

func (s Set[T]) Length() int {
	return len(s)
}

// --- 以下是具体的集合类型及特有方法 ---
// IntSet 基于泛型Set[int]定义
type IntSet Set[int]

// NewIntSet 针对IntSet的构造函数（也可以直接用NewSet[int]）
func NewIntSet(vs []int) IntSet {
	return IntSet(NewSet(vs))
}

// Stringify IntSet特有的字符串化方法
func (is IntSet) Stringify() string {
	vs := make([]int, 0, len(is))
	for v := range is {
		vs = append(vs, v)
	}
	sort.Ints(vs)
	ws := make([]string, 0, len(vs))
	for _, v := range vs {
		ws = append(ws, strconv.Itoa(v))
	}
	return strings.Join(ws, ",")
}

// StringSet 基于泛型Set[string]定义
type StringSet Set[string]

// NewStringSet 针对StringSet的构造函数（也可以直接用NewSet[string]）
func NewStringSet(vs []string) StringSet {
	return StringSet(NewSet(vs))
}

// Stringify StringSet特有的字符串化方法
func (ss StringSet) Stringify() string {
	vs := make([]string, 0, len(ss))
	for v := range ss {
		vs = append(vs, v)
	}
	return strings.Join(vs, ",")
}

// 测试示例
func main() {
	is := NewIntSet([]int{3, 1, 4, 1, 5})
	fmt.Println(is.Length())          // 输出4
	fmt.Println(is.Contains(3))       // 输出true
	fmt.Println(is.ContainsAny([]int{2, 6})) // 输出false
	fmt.Println(is.Stringify())       // 输出1,3,4,5

	ss := NewStringSet([]string{"apple", "banana", "apple", "cherry"})
	fmt.Println(ss.Length())          // 输出3
	fmt.Println(ss.Contains("banana"))// 输出true
	fmt.Println(ss.Stringify())       // 输出apple,banana,cherry（顺序可能因map遍历不同而变化）
}

方案优势 #

• 完全消除代码重复：核心方法逻辑只实现一次，所有基于泛型Set的具体类型都能复用。
• 类型安全：编译期就能检查元素类型是否正确，不需要interface{}的类型断言，避免运行时错误。
• 方法绑定关系保留：IntSet和StringSet仍然拥有自己的方法，调用方式和原来完全一致（比如is.Add(5)、ss.Add("test")）。
• 灵活性强：各自特有的方法（如Stringify）可以独立实现，不受泛型逻辑的限制。

兼容旧版本Go（1.18之前） #

如果你的项目还在使用Go 1.18以下的版本，泛型不可用，那么可以考虑用代码生成的方式：编写一个模板文件，然后用go generate命令自动生成IntSet和StringSet的方法代码。不过这种方式不如泛型优雅，建议优先升级Go版本使用泛型方案。

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