网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang泛型编程初体验

2020-06-10 03:06:18 admin 633

## 序言

众所周知，Golang中不支持类似C++/Java中的标记式泛型，所以对于常用算法，比如冒泡排序算法，有些同学容易写出逻辑上重复的代码，即整型是第一套代码，字符串型是第二套代码，用户自定义类型是第三套代码。  
重复是万恶之源，我们当然不能容忍，所以要消除重复，使得代码保持在最佳的状态。本文通过一个实际使用的简单算法的演进过程，初次体验了Golang的泛型编程，消除了重复代码，非常自然。

## 需求一：切片算法支持整型

今天是星期二，天气晴朗，万里无云，空气清新，我在办公室里听着音乐写着代码，开始了今天的工作。  
“小哥，数组切片有没有add和remove函数，可以方便的将元素添加和删除？”  
我抬头一看，是小明，就回答道：“什么类型的数组切片？”  
小明说：“整型。”  
”数组切片中的元素能不能有相同的？“我追问道。  
”不能有相同的，我存的都是实体的Id。“小明肯定的回答。  
“哦，这个简单，我过会提供一个Slice类，有Add和Remove方法，支持整型。”我有点自信的回答。  
小明说完谢谢后，回到了办公位继续工作。

一个小时后，我写完了支持整型的切片算法：

type Slice []int
    
    func NewSlice() Slice {
        return make(Slice, 0)
    }
    
    func (this* Slice) Add(elem int) error {
        for _, v := range *this {
            if v == elem {
                fmt.Printf("Slice:Add elem: %v already exist\n", elem)
                return ERR_ELEM_EXIST
            }
        }
        *this = append(*this, elem)
        fmt.Printf("Slice:Add elem: %v succ\n", elem)
        return nil
    }
    
    func (this* Slice) Remove(elem int) error {
        found := false
        for i, v := range *this {
            if v == elem {
                if i == len(*this) - 1 {
                    *this = (*this)[:i]
    
                } else {
                    *this = append((*this)[:i], (*this)[i+1:]...)
                }
                found = true
                break
            }
        }
        if !found {
            fmt.Printf("Slice:Remove elem: %v not exist\n", elem)
            return ERR_ELEM_NT_EXIST
        }
        fmt.Printf("Slice:Remove elem: %v succ\n", elem)
        return nil
    }

小明看了我的实现后，说：”我试用一下？"  
“丑媳妇不怕见公婆。“我请他试用。

小明用了5分钟，写了下面的代码：

func main() {
        intSliceExec()
    }
    
    func intSliceExec() {
        fmt.Println("int slice start")
        slice := alg.NewSlice()
        slice.Add(1)
        fmt.Println("current int slice:", slice)
        slice.Add(2)
        fmt.Println("current int slice:", slice)
        slice.Add(2)
        fmt.Println("current int slice:", slice)
        slice.Add(3)
        fmt.Println("current int slice:", slice)
        slice.Remove(2)
        fmt.Println("current int slice:", slice)
        slice.Remove(2)
        fmt.Println("current int slice:", slice)
        slice.Remove(3)
        fmt.Println("current int slice:", slice)
        fmt.Println("int slice end")
    }

从试用代码中可以看出，整型数组切片中最多有三个元素[1 2
3]，元素2插入的第二次应该失败，同理元素2删除的第二次也应该失败，整型数组切片最后只剩下一个元素[1]。

go run运行代码后，日志如下：

查看日志，结果符合期望。

## 需求二：切片算法支持字符串

周三下午，睡完午觉后精神有点小抖擞，浏览者邮件，突然发现公司又接了一个大单，于是吃了会精神食量。  
”小哥，小哥！“  
我抬头一看，是小雷。  
”咋的啦，哥们？“我好奇的问道。  
”听说你昨天实现了一个数组切片算法，已支持整型，我现在想用字符串型的数组切片算法，你能提供不？"小雷有点着急的问道。  
我心里一想，Golang支持Any类型，即interface{}，同时字符串和整型一样都可以直接用”==“运算符比较两个元素是否相等，所以你懂的。  
”这个好实现，给我一首歌的时间就可以试用。“我说完后，就立刻修改起了代码。

两分钟后，我提供了新版本的代码：

type Slice []interface{}
    
    func NewSlice() Slice {
        return make(Slice, 0)
    }
    
    func (this* Slice) Add(elem interface{}) error {
        for _, v := range *this {
            if v == elem {
                fmt.Printf("Slice:Add elem: %v already exist\n", elem)
                return ERR_ELEM_EXIST
            }
        }
        *this = append(*this, elem)
        fmt.Printf("Slice:Add elem: %v succ\n", elem)
        return nil
    }
    
    func (this* Slice) Remove(elem interface{}) error {
        found := false
        for i, v := range *this {
            if v == elem {
                if i == len(*this) - 1 {
                    *this = (*this)[:i]
    
                } else {
                    *this = append((*this)[:i], (*this)[i+1:]...)
                }
                found = true
                break
            }
        }
        if !found {
            fmt.Printf("Slice:Remove elem: %v not exist\n", elem)
            return ERR_ELEM_NT_EXIST
        }
        fmt.Printf("Slice:Remove elem: %v succ\n", elem)
        return nil
    }

不难发现，改动很简单，只将三个地方的int改成了interface{}，一切都是这么自然。  
”哇塞，这么快？半首歌我还没听完。“小雷开森的说。  
”简单设计，呵呵！“我们不约而同的说出了这个大家最爱说又最难做到的XP实践。

这次有了拷贝这个强大的武器，小雷两分钟就写完了试用代码：

func main() {
        intSliceExec()
        fmt.Println("")
        stringSliceExec()
    }
    
    func stringSliceExec() {
        fmt.Println("string slice start")
        slice := alg.NewSlice()
        slice.Add("hello")
        fmt.Println("current string slice:", slice)
        slice.Add("golang")
        fmt.Println("current string slice:", slice)
        slice.Add("golang")
        fmt.Println("current string slice:", slice)
        slice.Add("generic")
        fmt.Println("current string slice:", slice)
        slice.Remove("golang")
        fmt.Println("current string slice:", slice)
        slice.Remove("golang")
        fmt.Println("current string slice:", slice)
        slice.Remove("generic")
        fmt.Println("current string slice:", slice)
        fmt.Println("string slice end")
    }
    ...

从试用代码中可以看出，字符串型数组切片中最多有三个元素[hello golang
generic]，元素golang插入的第二次应该失败，同理元素golang删除的第二次也应该失败，字符串型数组切片最后只剩下一个元素[hello]。

查看日志，结果符合期望。

### 需求三：切片算法支持用户自定义的类型

今天周四，眼看明天就周五了，打算中午出去吃个自助餐提高一下生活质量，于是叫着小方开着车就杀出去了。由于在一点半之前要回到公司上班，所以匆匆地找了一家自助餐店。  
“哇靠，人真多！”小方这样感叹道。  
“这个店应该搞成多种模式，比如选取大家常吃的几种套餐（A，C，D），这样百分之七十的上班族都会直接领套餐，就不会白白浪费排队时间了。”我不着边际的边想边说。  
“自助餐还是更有吸引力，顾客可以任意搭配，做到真正的私人订制，而套餐吃几次就腻味了。”小方反驳着对我说。  
...  
紧赶慢赶，终于，终于在一点半前回到了公司，于是又开始编码了。

“小哥，听说你实现了一个数组切片算法，既支持整型，又支持字符串型，我这还有一个小小需求。”  
我抬头一看，是小方，就问“啥子需求？“  
”我这边有自定义的struct类型，也想用数组切片算法。“小方大方的提出需求。  
”这个嘛，这个嘛，有点难度！“我边思考边回应：”给我半个小时，让我试试。“  
”好的，小哥。“小方说完后露出了惬意的笑。

我们先自定义一个类型：

type Student struct {
        id string
        name string
    }

Student类型有两个数据成员，即id和name。id是学号，全局我唯一；name是中文名字的拼音，可重复。  
用户自定义类型和基本类型(int或string)不同的是两个元素是否相等的判断方式不一样：

1. 基本类型(int或string)直接通过”==“运算符来判断；
  2. 用户自定义类型万千种种，数组切片算法中不可能知道，所以需要通过interface提供的方法进行两个元素是否相等的判断。

我们接着定义一个interface：

type Comparable interface {
        IsEqual(obj interface{}) bool
    }

只要用户自定义的类型实现了接口Comparable，就可以调用它的方法IsEqual进行两个元素是否相等的判断了，于是我们实现了Student类型的IsEqual方法：

func (this Student) IsEqual(obj interface{}) bool {
        if student, ok := obj.(Student); ok {
            return this.GetId() == student.GetId()
        }
        panic("unexpected type")
    }
    
    func (this Student) GetId() string {
        return this.id
    }

用户自定义的GetId方法是必要的，因为Id不一定就是数据成员，可能是由多个数据成员拼接而成。

我们将数组切片算法的易变部分”v == elem"抽出来封装成方法：

func isEqual(a, b interface{}) bool {
        return a == b
    }

于是数组切片的Add方法和Remove方法就变成：

func (this* Slice) Add(elem interface{}) error {
        for _, v := range *this {
            if isEqual(v, elem) {
                fmt.Printf("Slice:Add elem: %v already exist\n", elem)
                return ERR_ELEM_EXIST
            }
        }
        *this = append(*this, elem)
        fmt.Printf("Slice:Add elem: %v succ\n", elem)
        return nil
    }
    
    func (this* Slice) Remove(elem interface{}) error {
        found := false
        for i, v := range *this {
            if isEqual(v, elem) {
                if i == len(*this) - 1 {
                    *this = (*this)[:i]
    
                } else {
                    *this = append((*this)[:i], (*this)[i+1:]...)
                }
                found = true
                break
            }
        }
        if !found {
            fmt.Printf("Slice:Remove elem: %v not exist\n", elem)
            return ERR_ELEM_NT_EXIST
        }
        fmt.Printf("Slice:Remove elem: %v succ\n", elem)
        return nil
    }

于是数组切片算法对于支持用户自定义类型的改动仅仅局限于isEqual函数了，我们通过接口查询来完成代码修改：

func isEqual(a, b interface{}) bool {
        if comparable, ok := a.(Comparable); ok {
            return comparable.IsEqual(b)
        } else {
            return a == b
        }
    }

半个小时后，我完成了代码，叫小方过来试用。  
因为有拷贝这个强大的武器，小雷三分钟就写完了试用代码：

func main() {
        intSliceExec()
        fmt.Println("")
        stringSliceExec()
        fmt.Println("")
        structSliceExec()
    }
    
    func structSliceExec() {
        fmt.Println("struct slice start")
        xiaoMing := Student{"1001", "xiao ming"}
        xiaoLei := Student{"1002", "xiao lei"}
        xiaoFang := Student{"1003", "xiao fang"}
        slice := alg.NewSlice()
        slice.Add(xiaoMing)
        fmt.Println("current struct slice:", slice)
        slice.Add(xiaoLei)
        fmt.Println("current struct slice:", slice)
        slice.Add(xiaoLei)
        fmt.Println("current struct slice:", slice)
        slice.Add(xiaoFang)
        fmt.Println("current struct slice:", slice)
        slice.Remove(xiaoLei)
        fmt.Println("current struct slice:", slice)
        slice.Remove(xiaoLei)
        fmt.Println("current struct slice:", slice)
        slice.Remove(xiaoFang)
        fmt.Println("current struct slice:", slice)
        fmt.Println("struct slice end")
    }
    ...

从试用代码中可以看出，用户自定义类型的数组切片中最多有三个元素[{1001 xiao ming} {1002 xiao lei} {1003 xiao
fang}]，元素{1002 xiao lei}插入的第二次应该失败，同理元素{1002 xiao
lei}删除的第二次也应该失败，用户自定义类型的数组切片最后只剩下一个元素[{1001 xiao ming}]。

int slice start
    Slice:Add elem: 1 succ
    current int slice: [1]
    Slice:Add elem: 2 succ
    current int slice: [1 2]
    Slice:Add elem: 2 already exist
    current int slice: [1 2]
    Slice:Add elem: 3 succ
    current int slice: [1 2 3]
    Slice:Remove elem: 2 succ
    current int slice: [1 3]
    Slice:Remove elem: 2 not exist
    current int slice: [1 3]
    Slice:Remove elem: 3 succ
    current int slice: [1]
    int slice end
    
    string slice start
    Slice:Add elem: hello succ
    current string slice: [hello]
    Slice:Add elem: golang succ
    current string slice: [hello golang]
    Slice:Add elem: golang already exist
    current string slice: [hello golang]
    Slice:Add elem: generic succ
    current string slice: [hello golang generic]
    Slice:Remove elem: golang succ
    current string slice: [hello generic]
    Slice:Remove elem: golang not exist
    current string slice: [hello generic]
    Slice:Remove elem: generic succ
    current string slice: [hello]
    string slice end
    
    struct slice start
    Slice:Add elem: {1001 xiao ming} succ
    current struct slice: [{1001 xiao ming}]
    Slice:Add elem: {1002 xiao lei} succ
    current struct slice: [{1001 xiao ming} {1002 xiao lei}]
    Slice:Add elem: {1002 xiao lei} already exist
    current struct slice: [{1001 xiao ming} {1002 xiao lei}]
    Slice:Add elem: {1003 xiao fang} succ
    current struct slice: [{1001 xiao ming} {1002 xiao lei} {1003 xiao fang}]
    Slice:Remove elem: {1002 xiao lei} succ
    current struct slice: [{1001 xiao ming} {1003 xiao fang}]
    Slice:Remove elem: {1002 xiao lei} not exist
    current struct slice: [{1001 xiao ming} {1003 xiao fang}]
    Slice:Remove elem: {1003 xiao fang} succ
    current struct slice: [{1001 xiao ming}]
    struct slice end

查看日志，结果符合期望。

## 小结

本文通过一种轻松愉快的方式阐述了实际使用的数组切片算法的演进过程，同时也是笔者使用Golang进行泛型编程的第一次旅行，再次领略了Golang中interface的强大魅力，希望对读者也有一定的启发。

转载文章，原文链接： Golang泛型编程初体验

关键字词golang 初体验

分享到：

上一篇：Golang事务模型

下一篇：获取Goroutine Id的最佳实践

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang泛型编程初体验

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang泛型编程初体验

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

admin 1年前