Si vous rencontrez à nouveau anonymece mot , traitez-le comme sans nom méchant.
Code de structure de champ anonyme.
package main
import "fmt"
type Student struct {
string
int
//string //error:duplicate field string
//int //error:duplicate field string
}
func main() {
var s1 = Student{
"666"，
0，
}
fmt.Println(s1)
} Line 8 et Line 9 , si vous supprimez les commentaires, une erreur sera signalée.
Cela illustre un problème. S'il s'agit d'une structure champ anonyme , le type de champ anonyme ne peut pas être répété, comme indiqué dans le code ci-dessus.
Imbrication de structure, tout comme son nom, une structure imbrique une autre structure.
一个学生的信息，假设有姓名，年龄，性别，这三个字段。
这个学生必定要归属一个班级的，假设这个班级的信息有年级，几班，班主任姓名。
根据上述叙述，我们知道一定是有两个结构体的，至少一个是学生，一个是班级。
type Classes struct {
Grade int //年级
Class int //班级
TeacherName string //班主任姓名
}type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
class Classes //所属班级
}可以看到第5行代码，结构体的字段类型直接是一个结构体，这就是结构体嵌套、
当一个结构体不能完整描述一个对象时，或者说本来就是独立的对象有关联时，就需要结构体嵌套。
func main() {
var s1 = Student{
Name: "张三"，
Age: 18，
Gender: "男"，
class: Classes{
Grade: 2020，
Class: 1，
TeacherName: "张三的老师"，
}，
}
fmt.Println(s1)
}func main() {
var c1 = Classes{
Grade: 2020，
Class: 1，
TeacherName: "张三的老师"，
}
var s2 = Student{
Name: "张三"，
Age: 18，
Gender: "男"，
class: c1，
}
fmt.Println(s2)
}
其实方式一和方式二的本质是一样的，只不过是方式二将嵌套的结构体单独赋值了而已。
上述我们的Student结构体是这样写的。
type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
class Classes //所属班级
}但是其实第5行代码的字段是可以省略的，就像这样。
type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
Classes //所属班级
}但是在赋值时，就要注意了，因为Student结构体已经没有字段名了，所以就不能使用上述的方式赋值了
需要这种。
func main() {
var s1 = Student{
Name: "张三"，
Age: 18，
Gender: "男"，
Classes: Classes{
Grade: 2020，
Class: 1，
TeacherName: "张三的老师"，
}，
}
}没错，第5行的字段名是Classes结构体名。
执行结果还是一样的。
上述是直接通过定义变量时就直接赋值了。
其实不管是结构体，还是嵌套结构体，都还有一种方法，就是通过.的方式赋值，代码如下。
默认的结构体嵌套，结构体还是有字段名的。
type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
class Classes //所属班级
}所以赋值代码如下。
func main() {
var s1 Student
s1.Name = "张三"
s1.Age = 18
s1.Gender = "男"
s1.class.Grade = 2020
s1.class.Class = 1
s1.class.TeacherName = "张三的老师"
fmt.Println(s1)
}第6行代码开始，通过s1找到class这个字段，再根据class找到class具体对应的值进行赋值。
匿名嵌套字段是没有字段名的，是有一个字段类型。
type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
Classes //所属班级
}所以赋值跟上述也不太一样，是这样的。
func main() {
var s1 Student
s1.Name = "张三"
s1.Age = 18
s1.Gender = "男"
s1.Classes.Grade = 2020
s1.Classes.Class = 1
s1.Classes.TeacherName = "张三的老师"
fmt.Println(s1)
}通过s1直接找到Classes这个结构体，再根据这个结构体找到里面具体的值，进行赋值。
其实跟定义变量时赋值相似。
Mais après tout, le résultat de l'exécution est toujours le même, mais le formulaire de mission est différent.
Elle peut être trouvée lors de la réaffectation selon structure imbriquée et structure imbriquée anonyme.
Si la structure imbriquée a un nom de champ, recherchez le champ spécifique via le nom du champ et attribuez la valeur.
S'il s'agit d'un champ anonyme d'une structure imbriquée, utilisez le nom de la structure imbriquée pour trouver le champ spécifique et attribuez-le.
Ce problème de conflit est en fait relativement rare. Ce problème ne se produit généralement que dans les scénarios d'imbrication anonyme.
C'est toujours la structure ci-dessus, mais la mission peut être faite comme ça.
func main() {
var s1 Student
s1.Name = "张三"
s1.Age = 18
s1.Gender = "男"
s1.Classes.Grade = 2020
s1.Classes.Class = 1
s1.Classes.TeacherName = "张三的老师"
//######### 分割 ##########
s1.Grade = 2020 //省去了Classes
s1.Class = 1 //省去了Classes
s1.TeacherName = "张三的老师" //省去了Classes
fmt.Println(s1)
}第10行，直接通过s1.Grade赋值，其实是省去了一个Classes，但是这种操作，只有在匿名嵌套结构体中可以使用。
但是如果我将结构体改成这样子。
//班级
type Classes struct {
Grade int //年级
Class int //班级
TeacherName string //班主任姓名
}
//课程
type Course struct {
CourseName string //课程名字
TeacherName string //任课老师姓名
}
//学生
type Student struct {
Name string //姓名
Age int //年龄
Gender string //性别
Classes //所属班级
Course //任课老师
}Student结构体有两个匿名嵌套结构体，一个是Classes，一个是Course。
但是有一个字段，是冲突的，就是TeacherName，如果还是通过懒的方式赋值，会发生什么呢？
func main() {
var s1 Student
s1.Name = "张三"
s1.Age = 18
s1.Gender = "男"
s1.Grade = 2020
s1.Class = 1
s1.TeacherName = "张三的老师"
fmt.Println(s1)
}第8行，直接找TeacherName字段，这时候就会出问题了。
意思很简单，就是不知道是Classes的TeacherName还是Course的TeacherName。
这时候，就必须要指定了。
s1.Classes.TeacherName = "张三的班主任" s1.Course.TeacherName = "张三的任课老师"
个人建议，还是尽量不要使用匿名嵌套结构体。
如果使用了匿名嵌套结构体，尽可能的采用标准方式赋值，不要采用懒得方式。
如果采用了懒的方式，一定要注意有没有字段冲突。
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!
Utilisation du mot-clé Type dans Go
Comment implémenter une liste chaînée en go
Que sont les logiciels de programmation en langage Go ?
Comment apprendre le langage go à partir de 0 bases
Quelles sont les méthodes pour implémenter la surcharge d'opérateurs en langage Go ?
Quels sont les opérateurs en langage Go ?
Comment utiliser la fonction de tri
Quel logiciel de test de batterie d'ordinateur portable est le meilleur ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
