Maison > Article > développement back-end > A quoi sert l’interface de Golang ?
Dans Golang, une interface est un type utilisé pour envelopper des méthodes. Ses fonctions sont : 1. En tant que wrapper pour les méthodes de conception orientée objet 2. En tant que support de diverses données, peut être utilisé pour recevoir des fonctions ; paramètres, etc La syntaxe de définition de l'interface est "type interface type name interface{method name (parameter list 1) return value list}" lorsque la première lettre du nom de la méthode est en majuscule et la première lettre du nom du type d'interface est également en majuscule, cette méthode peut être utilisée par le package où se trouve l'interface (package) en dehors de l'accès au code.
L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.
L'interface est une combinaison de signatures de méthodes Nous utilisons l'interface pour définir un ensemble de comportements d'un objet.
(Notez la différence entre la méthode et la fonction ordinaire)
L'interface est un type différent des interfaces des langages ordinaires. Elle est uniquement utilisée pour envelopper les méthodes. Cependant, c’est ce type de convergence qui fait que le langage GO a une orientation objet basée sur les fonctions.
Les principales fonctions de l'interface :
1. En tant que convergence de méthodes pour la conception orientée objet.
2. En tant que support de diverses données, il peut être utilisé pour recevoir des paramètres de fonction, etc.
C'est également le cas, le langage GO prône une programmation orientée interface.
2.1 Définition
Structure similaire
type 接口类型名 interface{ 方法名1( 参数列表1 ) 返回值列表1 方法名2( 参数列表2 ) 返回值列表2 … }
Bien sûr, il ne s'agit que d'une définition d'interface avec des méthodes, non utilisée pour les interfaces orientées données.
Nom de l'interface : utilisez le type pour définir l'interface en tant que nom de type personnalisé. Lorsque vous nommez les interfaces du langage Go, er est généralement ajouté après le mot. Par exemple, l'interface avec les opérations d'écriture s'appelle Writer, et l'interface avec la fonction de chaîne s'appelle Stringer, etc. Il est préférable que le nom de l'interface mette en évidence la signification du type de l'interface.
Nom de la méthode : lorsque la première lettre du nom de la méthode est en majuscule et que la première lettre du nom du type d'interface est également en majuscule, cette méthode est accessible par code en dehors du package où se trouve l'interface.
Liste des paramètres, liste des valeurs de retour : les noms de variables de paramètres dans la liste des paramètres et la liste des valeurs de retour peuvent être omis
2.2 Utilisation de
Tant qu'un objet implémente toutes les méthodes de l'interface , alors cette interface sera implémentée. En d'autres termes, une interface est une liste de méthodes qui doivent être mises en œuvre .
//定义接口 type FastfoodStore interface{ MakeHamberger() MakeFriedChips() MakeSoftDrink() } //定义结构体 type KFC struct{} type HambergerKing struct{} //实现了接口中所有的方法 func (kfc KFC) MakeHamberger(){ fmt.println("肯德基的汉堡") } func (kfc KFC) MakeFriedChips(){ fmt.println("肯德基的薯条") } func (kfc KFC) MakeSoftDrink(){ fmt.println("肯德基的饮料") } func (K *HambergerKing) MakeHameberger(){ fmt.println("汉堡王的汉堡") } func (K *HambergerKing) MakeFriedChips(){ fmt.println("汉堡王的薯条") } func (K *HambergerKing) MakeSoftDrink(){ fmt.println("汉堡王的饮料") }
On voit que contrairement à l'interface de Java, qui est explicitement implémentée, le langage de Go est implémenté implicitement.
Alors, comment fonctionne le langage Go ; check Est-ce que ce type est une interface ?
Réponse : Le langage Go vérifiera uniquement si un type implémente l'interface lors de la transmission des paramètres, du renvoi des paramètres et de l'affectation des variables. Du point de vue du processus de vérification de type, le compilateur vérifie le type uniquement lorsque cela est nécessaire. Lorsqu'un type implémente une interface, il lui suffit d'implémenter toutes les méthodes de l'interface et n'a pas besoin d'être explicitement déclaré comme dans les langages de programmation. comme Java.
Nous pouvons voir que lors de l'implémentation de l'interface ci-dessus, KFC est implémenté à l'aide d'objets de structure, tandis que Hamberger King est implémenté via des pointeurs. Quelle est la différence entre les deux ?
Réponse : La différence est lorsque nous initialisons l'interface
//结构体初始化和指针初始化 var f faststore = KFC{} //可以通过编译 var f faststore = &KFC{} //可以通过编译 var f faststore = HambergerKing{} //无法通过编译 var f faststore = &HambergerKing{} //可以通过编译
Alors pourquoi cela ne fonctionne-t-il pas lorsque nous utilisons des pointeurs pour implémenter et initialiser la structure ?
Réponse : Le langage Go transmet les paramètres par valeur.
Comme le montre l'image ci-dessus, quel que soit le pointeur de variable ou la structure initialisée dans le code ci-dessus, la copie de valeur se produira lors de l'appel de la méthode :
如上图左侧,对于 &HambergerKing{} 来说,这意味着拷贝一个新的 &HambergerKing{} 指针,这个指针与原来的指针指向一个相同并且唯一的结构体,所以编译器可以隐式的对变量解引用(dereference)获取指针指向的结构体;
如上图右侧,对于 HambergerKing{} 来说,这意味着方法会接受一个全新的 HambergerKing{},因为方法的参数是*HambergerKing,编译器不会无中生有创建一个新的指针;即使编译器可以创建新指针,这个指针指向的也不是最初调用该方法的结构体;
上面的分析解释了指针类型的现象,当我们使用指针实现接口时,只有指针类型的变量才会实现该接口;当我们使用结构体实现接口时,指针类型和结构体类型都会实现该接口。当然这并不意味着我们应该一律使用结构体实现接口,这个问题在实际工程中也没那么重要,在这里我们只想解释现象背后的原因。
在上面我们说过,interface有两种用法,现在介绍了其中一种就是作为方法的收束器。那么第二种就是作为数据的承载者。
2.3 数据承载者
作为数据容器时,接口就是一个“空”接口,这个空来形容没有Method。空interface(interface{})不包含任何的method,正因为如此,所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method),但是空interface在我们需要存储任意类型的数值的时候相当有用,因为它可以存储任意类型的数值。它有点类似于C语言的void*类型。
需要注意的是,与 C 语言中的 void * 不同,interface{} 类型不是任意类型。如果我们将类型转换成了 interface{} 类型,变量在运行期间的类型也会发生变化,获取变量类型时会得到 interface{}。
我们尝试从底层实现来解释两种用法的不同,你会好理解一些。Go 语言使用 runtime.iface 表示第一种接口,使用 runtime.eface 表示第二种不包含任何方法的接口 interface{},两种接口虽然都使用 interface 声明,但是由于后者在 Go 语言中很常见,所以在实现时使用了特殊的类型。
空接口作为函数的参数
使用空接口实现可以接收任意类型的函数参数。
// 空接口作为函数参数 func show(a interface{}) { fmt.Printf("type:%T value:%v\n", a, a) }
空接口作为map的值
使用空接口实现可以保存任意值的字典。
// 空接口作为map值 var studentInfo = make(map[string]interface{}) studentInfo["name"] = "Wilen" studentInfo["age"] = 18 studentInfo["married"] = false fmt.Println(studentInfo) //gin框架的gin.H{}
interface 可以存储所有的值,那么自然会涉及到类型转换这个话题。与此同时,我们也将在这节细说类型转换中,因为结构体实现和结构体指针实现的接口的异同。
3.1结构体指针实现接口
//我们仍然运用上面快餐店的例子 type Store interface{ MakeHamberger() } type KFC struct{ name string } func (k *KFC) MakeHamberger(){ fmt.println(k.name+"制作了一个汉堡") } func main(){ var s store = &KFC{name:"东街店"} store.MakeHamberger() }
这里将上述代码生成的汇编指令拆分成三部分分析:
KFC的初始化又可以分为下面几步:
获取 KFC 结构体类型指针并将其作为参数放到栈上;
通过 CALL 指定调用 runtime.newobject函数,这个函数会以 KFC 结构体类型指针作为入参,分配一片新的内存空间并将指向这片内存空间的指针返回到 SP+8 上;
SP+8 现在存储了一个指向 KFC 结构体的指针,我们将栈上的指针拷贝到寄存器 DI 上方便操作;
由于 Cat 中只包含一个字符串类型的 Name 变量,所以在这里会分别将字符串地址 &"东街店" 和字符串长度 6 设置到结构体上。
因为 KFC 结构体的定义中只包含一个字符串,而字符串在 Go 语言中总共占 16 字节,所以每一个 KFC 结构体的大小都是 16 字节。初始化 KFC 结构体之后就进入了将 *KFC 转换成 Store 类型的过程了:
类型转换的过程比较简单,Store 作为一个包含方法的接口,它在底层使用 [runtime.iface] 结构体表示。runtime.iface 结构体包含两个字段,其中一个是指向数据的指针,另一个是表示接口和结构体关系的 tab 字段,我们已经通过上一段代码 SP+8 初始化了 KFC 结构体指针,这段代码只是将编译期间生成的 runtime.itab 结构体指针复制到 SP 上:
到这里,我们会发现 SP ~ SP+16 共同组成了 runtime.iface 结构体。
栈上的这个 runtime.iface 也是 MakeHamberger() 方法的第一个入参。通过CALL()完成方法的调用。
3.2 结构体实现接口
//我们仍然运用上面快餐店的例子 type Store interface{ MakeHamberger() } type KFC struct{ name string } func (k KFC) MakeHamberger(){ fmt.println(k.name+"制作了一个汉堡") } func main(){ var s store = KFC{name:"东街店"} store.MakeHamberger() }
如果我们在初始化变量时使用指针类型 &KFC{Name: "东街店"} 也能够通过编译,不过生成的汇编代码和上一节中的几乎完全相同,所以这里也就不分析这个情况了。
在栈上初始化 KFC 结构体,而上一节的代码在堆上申请了 16 字节的内存空间,栈上只有一个指向 KFC 的指针。
初始化结构体后会进入类型转换的阶段,编译器会将 go.itab."".KFC,"".Store 的地址和指向 KFC 结构体的指针作为参数一并传入 runtime.convT2I 函数:这个函数会获取 runtime.itab 中存储的类型,根据类型的大小申请一片内存空间并将 elem 指针中的内容拷贝到目标的内存中:
func convT2I(tab *itab, elem unsafe.Pointer) (i iface) { t := tab._type x := mallocgc(t.size, t, true) typedmemmove(t, x, elem) i.tab = tab i.data = x return }
runtime.convT2I 会返回一个 runtime.iface,其中包含 runtime.itab 指针和 KFC 变量。当前函数返回之后,main 函数的栈上会包含以下数据:
SP 和 SP+8 中存储的 runtime.itab 和 KFC 指针是 runtime.convT2I 函数的入参,这个函数的返回值位于 SP+16,是一个占 16 字节内存空间的 runtime.iface 结构体,SP+32 存储的是在栈上的 KFC 结构体,它会在 runtime.convT2I 执行的过程中拷贝到堆上。
3.3类型断言
如何将一个接口类型转换成具体类型?
x.(T)
func main() { var c Store = &KFC{Name: "东街店"} switch c.(type) { case *KFC: kfc := c.(*KFC) kfc.MakeHamberger() } }
因为 Go 语言的编译器做了一些优化,所以代码中没有runtime.iface 的构建过程,不过对于这一节要介绍的类型断言和转换没有太多的影响。
switch语句生成的汇编指令会将目标类型的 hash 与接口变量中的 itab.hash 进行比较
func main() { var c interface{} = &KFC{Name: "东街店"} switch c.(type) { case *KFC: kfc := c.(*KFC) kfc.MakeHamberger() } }
上述代码会在类型断言时就不是直接获取变量中具体类型的 runtime._type,而是从 eface._type 中获取,汇编指令仍然会使用目标类型的 hash 与变量的类型比较.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!