Avant-propos
Récemment, j'ai lu un site Web et posé une question à un étudiant sur la différence entre une méthode en Golang où le récepteur est un pointeur et une méthode qui n'est pas un pointeur. Ici, je vais l'expliquer de manière simple et facile. -pour comprendre une façon d'aider les étudiants qui viennent d'apprendre le Golang
Quelle est la méthode
En fait, tant que vous comprenez ce principe, vous pouvez fondamentalement comprendre les problèmes mentionnés ci-dessus.
La méthode est en fait une fonction spéciale, et le récepteur est le premier paramètre transmis implicitement.
Par exemple
type test struct{
name string
}
func (t test) TestValue() {
}
func (t *test) TestPointer() {
}
func main(){
t := test{}
m := test.TestValue
m(t)
m1 := (*test).TestPointer
m1(&t)
}
Est-il facile de compris ? Maintenant, ajoutons du code pour voir la différence entre les pointeurs et les non-pointeurs.
type test struct{
name string
}
func (t test) TestValue() {
fmt.Printf("%p\n", &t)
}
func (t *test) TestPointer() {
fmt.Printf("%p\n", t)
}
func main(){
t := test{}
//0xc42000e2c0
fmt.Printf("%p\n", &t)
//0xc42000e2e0
m := test.TestValue
m(t)
//0xc42000e2c0
m1 := (*test).TestPointer
m1(&t)
} Je suppose que certains étudiants ont compris que lorsque le paramètre réel est transmis alors qu'il ne s'agit pas d'un pointeur, la valeur est copiée. Par conséquent, chaque fois que TestValue() est appelé, la valeur est copiée
Si cela implique l'opération de modification de la valeur, quel sera le résultat ?
type test struct{
name string
}
func (t test) TestValue() {
fmt.Printf("%s\n",t.name)
}
func (t *test) TestPointer() {
fmt.Printf("%s\n",t.name)
}
func main(){
t := test{"wang"}
//这里发生了复制,不受后面修改的影响
m := t.TestValue
t.name = "Li"
m1 := (*test).TestPointer
//Li
m1(&t)
//wang
m()
}
Tous les étudiants doivent donc faire attention lorsqu'ils rencontrent de tels problèmes. problèmes de programmation.
Quelle est la relation entre ces ensembles de méthodes ? Ici j'ai emprunté à l'étude de qyuhen en golang Quant à la prise de notes, je recommande aussi aux amis qui aiment le golang de lire ce livre, qui sera d'une grande aide pour approfondir leur compréhension du golang.
• L'ensemble de méthodes de type T contient toutes les méthodes du récepteur T.
• L'ensemble des méthodes de type T contient toutes les méthodes du récepteur T + T.
• Si le type S contient un champ anonyme T, alors l'ensemble de méthodes de S contient T méthodes.
• Si le type S contient le champ anonyme T, alors l'ensemble de méthodes de S contient les méthodes T + T.
• Indépendamment de l'intégration de T ou T, l'ensemble des méthodes S contient toujours les méthodes T + *T.
Conclusion
Bien que Golang soit simple et facile à utiliser, il présente encore de nombreux pièges L'auteur a rencontré de nombreux pièges dans le processus d'utilisation de Golang, qui seront mentionnés dans le blog. plus tard. Tout le monde est le bienvenu. Discutons ensemble.