如何将 int 和 string 集合的通用方法重构为通用基类？

从现在开始，努力学习吧！本文《如何将 int 和 string 集合的通用方法重构为通用基类？》主要讲解了等等相关知识点，我会在编程网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

考虑以下程序，它分别为包含 ints 和 strings 的集合定义两种类型 intset 和 stringset。

这几个类型的add()、addrange()、contains()、containsany、length()基本相同(只是参数类型不同)。

我可以定义独立函数 add()、addrange()...，无需方法接收器，并使用 interface{} 参数为 intset 或 stringset，但我希望这些方法与集合保持耦合。

如果我使用组合，则基本结构无法访问子结构的 map[...]bool。

重构上述五种方法以消除代码重复的正确方法是什么？

程序：

package main

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


type IntSet map[int]bool
type StringSet map[string]bool

func NewStringSet(vs []string) StringSet {
    ss := StringSet{}
    for _, v := range vs {
        ss.Add(v)
    }
    return ss
}

func (ss StringSet) Add(v string) bool {
    _, found := ss[v]
    ss[v] = true
    return !found
}

func (ss StringSet) AddRange(vs []string) {
    for _, v := range vs {
        ss[v] = true
    }
}

func (ss StringSet) Contains(v string) bool {
    _, found := ss[v]
    return found
}

func (ss StringSet) ContainsAny(vs []string) bool {
    for _, v := range vs {
        if _, found := ss[v]; found {
            return true
        }
    }
    return false
}

func (ss StringSet) Length() int {
    return len(ss)
}

func (ss StringSet) Stringify() string {
    vs := make([]string, len(ss))
    i := 0
    for v := range ss {
        vs[i] = v
        i++
    }
    return strings.Join(vs, ",")
}

func NewIntSet(vs []int) IntSet {
    is := IntSet{}
    for _, v := range vs {
        is.Add(v)
    }
    return is
}

func (is IntSet) Add(v int) bool {
    _, found := is[v]
    is[v] = true
    return !found
}

func (is IntSet) AddRange(vs []int) {
    for _, v := range vs {
        is[v] = true
    }
}

func (is IntSet) Contains(v int) bool {
    _, found := is[v]
    return found
}

func (is IntSet) ContainsAny(vs []int) bool {
    for _, v := range vs {
        if _, found := is[v]; found {
            return true
        }
    }
    return false
}

func (is IntSet) Length() int {
    return len(is)
}

func (is IntSet) Stringify() string {
    vs := make([]int, 0)
    for v := range is {
        vs = append(vs, v)
    }
    sort.Ints(vs)
    ws := make([]string, 0)
    for v := range vs {
        s := strconv.Itoa(v)
        ws = append(ws, s)
    }
    return strings.Join(ws, ",")
}

正确答案

只需保留重复的代码即可。就维护开销而言，五种方法不是问题。

无论如何，这里有一个关于泛型的强制性示例，它也适用于 Go2 playground：

package main

import (
    "fmt"
)

type Set[T comparable] map[T]bool

func NewSet[T comparable](vs []T) Set[T] {
    ss := Set[T]{}
    for _, v := range vs {
        ss.Add(v)
    }
    return ss
}

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)
}

func (s Set[T]) Stringify() string {
    vs := make([]interface{}, len(s))
    i := 0
    for v := range s {
        vs[i] = v
        i++
    }
    return fmt.Sprintf("%v", vs)
}

func main() {
    sset := NewSet([]string{"foo", "bar"})
    sset.Add("baz")
    fmt.Println(sset.Stringify()) // [foo bar baz]

    iset := NewSet([]int{12, 13, 14})
    iset.Add(20)
    fmt.Println(iset.Stringify()) // [12 13 14 20]
}

特别是：

• set 的类型参数中使用的约束必须是 comparable，因为映射键必须支持比较运算符（==、!=）
• 类型参数必须在所有接收器中显式重复，但约束不需要重复。所以你在所有方法中都有 func (s set[t]) ...
• stringify() 的实现很麻烦，因为类型参数 t 可比较的 不支持字符串操作。这只是一个可比的。所以上面我天真地使用了 []interface{} 和 fmt.sprintf，它就完成了工作

本篇关于《如何将 int 和 string 集合的通用方法重构为通用基类？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注编程网公众号！