• 结构体struct类似python语言中的类class,结构体类的元素可以是一个变量，或者函数或者其它的类型，好比python的属性和方法。

  // struct结构体，类似python语言中的class类
  package main
  import "fmt"
  type person struct { //定义一个strcut
      Name string
      Age  int
  }
  
  func main() {
      a := person{}    //赋值给一个变量a
      fmt.Println(a)
      a.Name = "faily"  //为结构体赋值
      a.Age = 28
      fmt.Println(a)
  }
  /*输出结果
      { 0}            //空结构体时，int元素为0
  {faily 28}
  */

• 简单的方式进行结构体的初始化

  package main
  import "fmt"
  
  type person struct { //定义一个strcut
      Name string
      Age  int
  }
  func main() {
      a := person{ //也可以这样初始化一个结构体
          Name: "msy",
          Age:  27,
      }
      fmt.Println(a)
  }

• struct也是一个值类型,也就是说传递的时候，拷贝的是值,正常途径无法改变结构内的值，需通过指针的方式进行修改

  package main
  import "fmt"
  
  type person struct { //定义一个strcut
      Name string
      Age  int
  }
  
  func main() {
      a := person{ //初始化结构体
          Name: "msy",
          Age:  27,
      }
      fmt.Println("1", a)
      A(a)
      fmt.Println("3", a)
      B(&a)           //指针引用
      fmt.Println("4", a)
  
  }
  
  func A(per person) { // 参数引用person--结构体
      per.Age = 13    //初始化person属性的值
      fmt.Println("2", per)
  }
  
  func B(per *person){    //传递指针
      per.Age =13
      fmt.Println("2",per)
  }
  /*输出
  初始化：        1 {msy 27}
  修改A：        2 {msy 13}
  修改失败：   3'{msy 27}
  修改B：        2 {msy 13}
  修改成功：   3"{msy 13} 
  */

• 推荐结构体初始化时，使用结构体指针，修改的时候更加方便

  package main
  import "fmt"
  
  type person struct { //定义一个strcut
      Name string
      Age  int
  }
  
  func main() {
      a := &person{ //初始化结构体,建议使用结构的指针
          Name: "msy",
          Age:  27,
      }
      a.Name = "MYF" //这种方式就可以直接修改结构体
      fmt.Println("1", a)
      A(a) //此时就可以直接修改结构体
      B(a)
      fmt.Println("3", a)
  }
  
  func A(per *person) {           //传递指针
      per.Age = 13                //初始化person属性的值
      fmt.Println("2", per)
  }
  
  func B(per *person) { //传递指针
      per.Age = 100
      fmt.Println("2", per)
  }
  
  /*输出
  1 &{MYF 27}
  2 &{MYF 13}
  2 &{MYF 100}
  3 &{MYF 100}
  */

• 匿名结构:没有名字的结构

  package main
  import "fmt"
  
  func main() {
      a := &struct {      //指向结构体指针
          Name string
          Age  int
      }{                  //直接初始化
          Name: "moshaoying",
          Age:  27,
      }   
      fmt。Println(a)
  }
  
  /*输出
  &{moshaoying 27}
  */

• 嵌套匿名结构体，初始化方式

  package main
  import "fmt"
  
  type person struct { //嵌套匿名结构
      Name    string
      Age     int
      Content struct {
          Phone int
          Addr  string
      }
  }
  
  func main() {
      a := person{Name: "moshaoying", Age: 22}
      a.Content.Phone = 13636269334       //嵌套匿名结构体初始化方式
      a.Content.Addr = "shanxi,xian"
  
      fmt.Println(a)
  }
  
  /*输出
  {moshaoying 22 {13636269334 shanxi,xian}}
  */

• 结构体比较： 命名是结构体的一部分，所以只有当结构体命名相同时才可以进行比较

  package main
  import "fmt"
  
  type person struct { //嵌套匿名结构
      Name string
      Age  int
  }
  
  type person1 struct {
      Name string
      Age  int
  }
  
  func main() {
      a := person{Name: "moshaoying", Age: 22}
      b := person1{Name: "moshaoying", Age: 22}
      c := person{Name: "moshaoying", Age: 22}
      d : =  person{Name: "moshaoying", Age: 21}
      fmt.Println(a == b)
      fmt.Println(a == c)
      fmt.Println(a == d)
  }
  
  /*输出报错
  a=b     invalid operation: a == b (mismatched types person and person1)
  a=c     true
  a=d     false
  */

• 结构体没有python类的继承，但是结构体也会有类似的功能，结构体嵌套，达到继承其它结构体的属性

  package main
  import "fmt"
  
  type human struct {
      Sex int
  }
  type person struct { //结构体继承(嵌套)
      human
      Name string
      Age  int
  }
  
  func main() {
      a := person{Name: "failymao", Age: 22, human: human{Sex: 250}} //第一种方式，注意原理
      fmt.Println(a)
      //第二种方式
      a.Name = "allen"
      a.Age = 29
      a.Sex = 222
      fmt.Println(a)
  }
  
  /*输出报错
  第