为什么在Go语言中要少用interface{}

记得刚从Java转Go的时候,一个用Go语言的前辈告诉我:“要少用interface{},这玩意儿很好用,但是最好不要用。”那时候我的组长打趣接话:“不会,他是从Java转过来的,碰到个问题就想定义个类。”当时我对interface{}的第一印象也是类比Java中的Object类,我们使用Java肯定不会到处去传Object啊。后来的事实证明,年轻人毕竟是年轻人,看着目前项目里漫天飞的interface{},它们时而变成函数形参让人摸不着头脑;时而隐藏在结构体字段中变化无穷。不禁想起以前看到的一句话:“动态语言一时爽,重构代码火葬场。”故而写下此篇关于interface{}的经验总结,供以后的自己和读者参考。

1. interface{}之对象转型坑

一个语言用的久了,难免使用者的思维会受到这个语言的影响,interface{}作为Go的重要特性之一,它代表的是一个类似 *void
的指针,可以指向不同类型的数据。所以我们可以使用它来指向任何数据,这会带来类似与动态语言的便利性,如以下的例子:

type BaseQuestion struct{
    QuestionId int
    QuestionContent string
}

type ChoiceQuestion struct{
    BaseQuestion
    Options []string
}

type BlankQuestion struct{
    BaseQuestion
    Blank string
}

func fetchQuestion(id int) (interface{} , bool) {
    data1 ,ok1 := fetchFromChoiceTable(id) // 根据ID到选择题表中找题目,返回(ChoiceQuestion)
    data2 ,ok2 := fetchFromBlankTable(id)  // 根据ID到填空题表中找题目,返回(BlankQuestion)
    
    if ok1 {
        return data1,ok1
    }
    
    if ok2 {
        return data2,ok2
    }
    
    return nil ,false
}

在上面的代码中,data1是 ChoiceQuestion
类型,data2是 BlankQuestion
类型。因此,我们的interface{}指代了三种类型,分别是 ChoiceQuestion
BlankQuestion
nil
,这里就体现了Go和面向对象语言的不同点了,在面向对象语言中,我们本可以这么写:

func fetchQuestion(id int) (BaseQuestion , bool) {
    ...
}

只需要返回基类 BaseQuestion
即可,需要使用子类的方法或者字段只需要向下转型。然而在Go中,并没有这种 is-A
的概念,代码会无情的提示你,返回值类型不匹配。

那么,我们该如何使用这个 interface{}
返回值呢,我们也不知道它是什么类型啊。所以,你得不厌其烦的一个一个判断:

func printQuestion(){
    if data, ok := fetchQuestion(1001); ok {
		switch v := data.(type) {
		case ChoiceQuestion:
			fmt.Println(v)
		case BlankQuestion:
			fmt.Println(v)
		case nil:
			fmt.Println(v)
		}
		fmt.Println(data)
	}
}

// ------- 输出--------
{{1001 CHOICE} [A B]}
data -  &{{1001 CHOICE} [A B]}

EN,好像通过Go的 switch-type
语法糖,判断起来也不是很复杂嘛。如果你也这样以为,并且跟我一样用了这个方法,恭喜你已经入坑了。

因为需求永远是多变的,假如现在有个需求,需要在 ChoiceQuesiton
打印时,给它的 QuestionContent
字段添加前缀 选择题
,于是代码变成以下这样:

func printQuestion() {
	if data, ok := fetchQuestion(1001); ok {
		switch v := data.(type) {
		case ChoiceQuestion:
		    v.QuestionContent = "选择题"+ v.QuestionContent
			fmt.Println(v)
			
		...
		fmt.Println(data)
	}
}

// ------- 输出--------
{{1001 选择题CHOICE} [A B]}
data -  {{1001 CHOICE} [A B]}

我们得到了不一样的输出结果,而data根本没有变动。可能有的读者已经猜到了, v
data
根本不是指向同一份数据,换句话说, v := data.(type)
这条语句,会新建一个data在对应 type
下的副本,我们对 v
操作影响不到data。当然,我们可以要求 fetchFrom***Table()
返回 *ChoiceQuestion
类型,这样我们可以通过判断 *ChoiceQuestion
来处理数据副本问题:

func printQuestion() {
	if data, ok := fetchQuestion(1001); ok {
		switch v := data.(type) {
		case *ChoiceQuestion:
		    v.QuestionContent = "选择题"+ v.QuestionContent
			fmt.Println(v)
		...
		fmt.Println(data)
	}
}
// ------- 输出--------
&{{1001 选择题CHOICE} [A B]}
data -  &{{1001 选择题CHOICE} [A B]}

不过在实际项目中,你可能有很多理由不能去动 fetchFrom***Table()
,也许是涉及数据库的操作函数你没有权限改动;也许是项目中很多地方使用了这个方法,你也不能随便改动。这也是我没有写出 fetchFrom***Table()
的实现的原因,很多时候,这些方法对你只能是黑盒的。退一步讲,即使方法签名可以改动,我们这里也只是列举出了两种题型,可能还有材料题、阅读题、写作题等等,如果需求要对每个题型的 QuestonContent
添加对应的题型前缀,我们岂不是要写出下面这种代码:

func printQuestion() {
	if data, ok := fetchQuestion(1001); ok {
		switch v := data.(type) {
		case *ChoiceQuestion:
		    v.QuestionContent = "选择题"+ v.QuestionContent
		    fmt.Println(v)
		case *BlankQuestion:
		    v.QuestionContent = "填空题"+ v.QuestionContent
		    fmt.Println(v)
		case *MaterialQuestion:
		    v.QuestionContent = "材料题"+ v.QuestionContent
		    fmt.Println(v)
		case *WritingQuestion:
		    v.QuestionContent = "写作题"+ v.QuestionContent
		    fmt.Println(v)
		... 
		case nil:
		    fmt.Println(v)
		fmt.Println(data)
	}
}

这种代码带来了大量的重复结构,由此可见, interface{}
的动态特性很不能适应复杂的数据结构,难道我们就不能有更方便的操作了么?山穷水尽之际,或许可以回头看看面向对象思想,也许继承和多态能很好的解决我们遇到的问题。

我们可以把这些题型抽成一个接口,并且让 BaseQuestion
实现这个接口。

type IQuestion interface{
    GetQuestionType() int
    GetQuestionContent()string
    AddQuestionContentPrefix(prefix string)
}

type BaseQuestion struct {
	QuestionId      int
	QuestionContent string
	QuestionType    int
}

func (self *BaseQuestion) GetQuestionType() int {
	return self.QuestionType
}

func (self *BaseQuestion) GetQuestionContent() string {
	return self.QuestionContent
}

func (self *BaseQuestion) AddQuestionContentPrefix(prefix string) {
	self.QuestionContent = prefix + self.QuestionContent
}

//修改返回值为IQuestion
func fetchQuestion(id int) (IQuestion, bool) {
	data1, ok1 := fetchFromChoiceTable(id) // 根据ID到选择题表中找题目
	data2, ok2 := fetchFromBlankTable(id)  // 根据ID到选择题表中找题目

	if ok1 {
		return &data1, ok1
	}

	if ok2 {
		return &data2, ok2
	}

	return nil, false
}

不管有多少题型,只要它们包含 BaseQuestion
,就能自动实现 IQuestion
接口,从而,我们可以通过定义接口方法来控制数据。

func printQuestion() {
	if data, ok := fetchQuestion(1002); ok {
		var questionPrefix string

        //需要增加题目类型,只需要添加一段case
		switch  data.GetQuestionType() {
		case ChoiceQuestionType:
		    questionPrefix = "选择题"
		case BlankQuestionType:
		    questionPrefix = "填空题"
		}

		data.AddQuestionContentPrefix(questionPrefix)
		fmt.Println("data - ", data)
	}
}

//--------输出--------
data -  &{{1002 填空题BLANK 2} [ET AI]}

这种方法无疑大大减少了副本的创建数量,而且易于扩展。通过这个例子,我们也了解到了Go接口的强大之处,虽然Go并不是面向对象的语言,但是通过良好的接口设计,我们完全可以从中窥探到面向对象思维的影子。也难怪在Go文档的FAQ中,对于 Is Go an object-oriented language?
这个问题,官方给出的答案是 yes and no.


这里还可以多扯一句,前面说了 v := data.(type)
这条语句是拷贝data的副本,但当data是接口对象时,这条语句就是接口之间的转型而不是数据副本拷贝了。

//定义新接口
type IChoiceQuestion interface {
	IQuestion
	GetOptionsLen() int
}

func (self *ChoiceQuestion) GetOptionsLen() int {
	return len(self.Options)
}

func showOptionsLen(data IQuestion) {
    //choice和data指向同一份数据
	if choice, ok := data.(IChoiceQuestion); ok {
	    fmt.Println("Choice has :", choice.GetOptionsLen())
	}
}

//------------输出-----------
Choice has : 2

2. interface{}之 nil

看以下代码:

func fetchFromChoiceTable(id int) (data *ChoiceQuestion) {
	if id == 1001 {
		return &ChoiceQuestion{
			BaseQuestion: BaseQuestion{
				QuestionId:      1001,
				QuestionContent: "HELLO",
			},
			Options: []string{"A", "B"},
		}
	}
	return nil
}


func fetchQuestion(id int) (interface{}) {
	data1 := fetchFromChoiceTable(id) // 根据ID到选择题表中找题目
	return data1
}

func sendData(data interface{}) {
	fmt.Println("发送数据 ..." , data)
}

func main(){
    data := fetchQuestion(1002)
    
    if data != nil {
        sendData(data)
    }
}

一串很常见的业务代码,我们根据id查询Question,为了以后能方便的扩展,我们使用 interface{}
作为返回值,然后根据data是否为 nil
来判断是不是要发送这个 Question
。不幸的是,不管 fetchQuestion()
方法有没有查到数据, sendData()
都会被执行。运行 main()
,打印结果如下:

发送数据 ... <nil>

Process finished with exit code 0

要明白内中玄机,我们需要回忆下 interface{}
究竟是个什么东西,文档上说,它是一个空接口,也就是说,一个没有声明任何方法的接口,那么,接口在Go的内部又究竟是怎么表示的?我在官方文档上找到一下几句话:

Under the covers, interfaces are implemented as two elements, a type and a value. The value, called the interface's dynamic value, is an arbitrary concrete value and the type is that of the value. For the int value 3, an interface value contains, schematically, (int, 3).

以上的话大意是说,interface在Go底层,被表示为一个值和值对应的类型的集合体,具体到我们的示例代码, fetchQuestion()
的返回值 interface{}
,其实是指(*ChoiceQuestion, data1)的集合体,如果没查到数据,则我们的data1为nil,上述集合体变成(*ChoiceQuestion, nil)。而Go规定中,这样的结构的集合体本身是非nil的,进一步的,只有(nil,nil)这样的集合体才能被判断为nil。

这严格来说,不是 interface{}
的问题,而是Go接口设计的规定,你把以上代码中的 interface{}
换成其它任意你定义的接口,都会产生此问题。所以我们对接口的判 nil
,一定要慎重,以上代码如果改成多返回值形式,就能完全避免这个问题。

func fetchQuestion(id int) (interface{},bool) {
	data1 := fetchFromChoiceTable(id) // 根据ID到选择题表中找题目
	if data1 != nil {
	    return data1,true
	}
	return nil,false
}

func sendData(data interface{}) {
	fmt.Println("发送数据 ..." , data)
}

func main(){
    if data, ok := fetchQuestion(1002); ok {
        sendData(data)
    }
}

当然,也有很多其它的办法可以解决,大家可以自行探索。

原文 

https://juejin.im/post/5ad1c766518825555e5e4646

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 为什么在Go语言中要少用interface{}

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址