Pourquoi `fmt.Println()` se comporte-t-il différemment avec les types incorporés dans Go lorsque les types incorporés ont des méthodes `String()` en conflit ?

Comportement ambigu de la méthode String() avec les types intégrés dans Go

Lorsque vous traitez des types intégrés dans Go, comprendre le comportement de la chaîne () peut être déroutante. Examinons ce comportement en fonction d'un exemple de code spécifique.

Considérez le code suivant :

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)
}

func main() {
    engineer := Engineer{
        Person: Person{
            Name: "John Doe",
            Age:  35,
        },
        TaxPayer: TaxPayer{3},
        Specialization: "Construction",
    }
    fmt.Println(engineer)
}

La sortie de ce code est :

{name: John Doe, age: 35 3 Construction}

Cependant, si Person.String() est supprimé, le résultat devient :

3

Et si TaxPayer.String() est également supprimé, la sortie devient :

{{John Doe 35} {3} Construction}

Au départ, il semble qu'il doit y avoir une méthode String() implicite pour la structure Engineer. Cependant, ce n'est pas le cas.

La méthode String() dans les types intégrés

Lorsque les types sont incorporés dans une structure, leurs champs et méthodes deviennent accessibles via le type d'intégration. Cette « promotion » des méthodes peut conduire à une ambiguïté si plusieurs types intégrés définissent une méthode portant le même nom, telle que String().

Dans l'exemple de code donné, puisque Person et TaxPayer ont tous deux une String() méthode, la promotion de ces méthodes au type Ingénieur provoque une ambiguïté. C'est pourquoi Engineer.String() entraîne une erreur de compilation.

Pourquoi aucune erreur d'ambiguïté lors de l'utilisation de fmt.Println()

Malgré l'ambiguïté dans l'ensemble de méthodes de Engineer. , fmt.Println(engineer) n'entraîne pas d'erreur de compilation. En effet, fmt.Println() appelle fmt.Fprint(os.Stdout, Engineer).

fmt.Fprint() vérifie si la valeur transmise implémente l'interface fmt.Stringer, qui inclut une méthode String() . Si tel est le cas, String() est utilisé pour produire une représentation sous forme de chaîne de la valeur.

Dans ce cas, puisque ni Person ni TaxPayer n'implémentent fmt.Stringer, le formatage par défaut (champs de structure) est utilisé à la place. Cela donne le résultat que nous voyons lorsque fmt.Println(engineer) est appelé.

Conclusion

Comprendre le comportement des types intégrés et la promotion de leurs méthodes est crucial en Aller. Lorsque plusieurs types incorporés définissent une méthode portant le même nom, cela peut conduire à une ambiguïté, entraînant des erreurs de compilation. Cependant, lors de l'utilisation de fmt.Println(), le formatage par défaut est utilisé lorsque la valeur transmise n'implémente pas fmt.Stringer.

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!