golang基础--strcut结构体

• 结构体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)
  }
  
  /*输出报错
  第一种方式：	{{250} failymao 22}
  第二种方式：	{{222} allen 29}
  */