package main
import "fmt"
type Aer interface{
Name()string
PrintName()
}
type A struct {
}
func (a *A) Name() string {
return "a"
}
func (a *A) PrintName() {
fmt.Println(a.Name())
}
type B struct {
A
}
func (b *B) Name() string {
return "b"
}
func getAer() Aer {
return &B{}
}
func main() {
a := getAer()
a.printName()
}
Dans cette implémentation, golang génère a. Cette implémentation viole l'implémentation habituelle de b en C++, Java et Python. Puisque les habitudes de pensée des langages ci-dessus ont été formées, alors cette implémentation. conduira à beaucoup de choses inattendues.
Hier, un frère qui l'a aimé dans golang实践群 (ce frère connaissait la question ci-dessus que j'ai posée et a dit qu'il s'agissait de l'implémentation de Golang) a demandé pourquoi quand UnmarshalJSON Le champ Test n'a reçu aucune valeur, et un problème a été soulevé dans golang
Son code est le suivant :
package main
import (
"encoding/json"
"fmt"
)
type request struct {
Operations map[string]op `json:"operations"`
}
type op struct {
operation
Test string `json:"test"`
}
type operation struct {
Width int `json:"width"`
Height int `json:"height"`
}
func (o *operation) UnmarshalJSON(b []byte) error {
type xoperation operation
xo := &xoperation{Width: 500, Height: 500}
if err := json.Unmarshal(b, xo); err != nil {
return err
}
*o = operation(*xo)
return nil
}
func main() {
jsonStr := `{
"operations": {
"001": {
"test":"test",
"width": 100
}
}
}`
req := request{}
json.Unmarshal([]byte(jsonStr), &req)
fmt.Println(req)
}
L'essence de ce problème est la même que celle que j'ai soulevée, car l'opération est intégrée dans l'op Donc avec. UnmarshalJSON, il est conforme à l'interface Unmarshaler dans le package json, donc lorsque l'interface est utilisée en interne pour le traitement, l'opération est satisfaite, mais ce qui est réellement traité est l'opération, c'est-à-dire que l'opération est utilisée comme entité pour effectuer UnmarshalJSON. , ce qui conduit à des messages d'erreur étranges.
Je pense que c'est un endroit très moche dans la mise en œuvre de Golang.
D'après ce que dit Brother Mouse, si les règles d'implémentation du langage sont connues, mais qu'il est quand même facile de faire des erreurs, alors c'est un piège.
Cet écueil du golang devra probablement être comblé à l'avenir.