Pourquoi ne détecte-t-il pas l'ambiguïté dans l'invocation de la méthode String() pour les structures intégrées au moment de la compilation ?

Invocation de méthodes étranges pour les structures intégrées dans Go : comprendre String()

Dans Go, les structures intégrées héritent des méthodes de leurs types intégrés. Cependant, lorsque plusieurs types incorporés définissent des méthodes portant le même nom, des ambiguïtés surviennent. Explorons ce comportement en nous concentrant sur la méthode String() en particulier.

Dans l'exemple de code fourni :

type Engineer struct {
    Person
    TaxPayer
    Specialization string
}

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("name: %s, age: %d", p.Name, p.Age)
}

type TaxPayer struct {
    TaxBracket int
}

func (t TaxPayer) String() string {
    return fmt.Sprintf("%d", t.TaxBracket)
}

Lorsque la structure Engineer est imprimée à l'aide de fmt.Println(engineer), le la sortie varie en fonction de la présence des méthodes String() dans les types intégrés.

Avec Person.String() :

• fmt appelle Person.String() car il a la profondeur la plus faible dans le type Engineer.
• Le résultat est : "{name : John Doe, âge : 35 ans 3 Construction}"

Sans Person.String() :

• fmt appelle TaxPayer.String() car c'est la seule méthode String() promue.
• Le résultat est : "3"

Sans les deux méthodes String() :

• Non La méthode String() peut être promue à partir des types intégrés.
• fmt imprime les valeurs de champ par défaut : "{{John Doe 35} {3} Construction}"

Ces scénarios mettent en évidence la règle de profondeur et la résolution d'ambiguïté pour les méthodes promues dans Go. Cependant, la question se pose de savoir pourquoi l'ambiguïté n'est pas détectée au moment de la compilation lorsque plusieurs méthodes String() avec une profondeur de zéro sont présentes.

Vérification du sélecteur ambigu :

Normalement, lorsque vous tentez d'invoquer une méthode avec un sélecteur ambigu, tel que Engineer.Foo(), une erreur de compilation se produit. Cependant, cela ne se produit pas avec les méthodes nommées String().

Raison :

Lors de l'impression d'une valeur sans appeler explicitement sa méthode String(), le fmt.Println La fonction vérifie si la valeur implémente fmt.Stringer. Il appelle ensuite la méthode String() implémentée. Étant donné que tous les types Go implémentent implicitement Stringer par défaut (https://golang.org/doc/go1.19#fmt), il existe toujours une méthode String() promue pour tout type.

Conclusion :

L'ambiguïté dans l'invocation de méthode pour les structures intégrées survient en raison de la règle de profondeur et de la gestion spéciale de la méthode String() pour l'impression des valeurs. En comprenant ces règles et les différences subtiles dans la promotion des méthodes, les développeurs peuvent éviter les comportements inattendus et maintenir la clarté du code dans les programmes Go.

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!