Go开发基础入门——3

Go 向函数传递指针参数

• Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可

  package main
  
  import "fmt"
  
  func main() {
      /* 定义局部变量 */
      var a int = 100
      var b int = 200
  
      fmt.Printf("交换前 a 的值 : %d\n", a)
      fmt.Printf("交换前 b 的值 : %d\n", b)
  
      /* 调用函数用于交换值
      * &a 指向 a 变量的地址
      * &b 指向 b 变量的地址
      */
      swap(&a, &b)
  
      fmt.Printf("交换后 a 的值 : %d\n", a)
      fmt.Printf("交换后 b 的值 : %d\n", b)
  }
  
  func swap(x *int, y *int) {
      var temp int
      temp = *x /* 保存 x 地址的值 */
      *x = *y   /* 将 y 赋值给 x */
      *y = temp /* 将 temp 赋值给 y */
  }
  输出结果：
  
  交换前 a 的值 : 100
  交换前 b 的值 : 200
  交换后 a 的值 : 200
  交换后 b 的值 : 100

自定义类型Struct

• Go中的 struct：

  可将类型分为命名和未命名两大类。命名类型包括 bool、int、string 等，而 array、slice、map 等和具体元素类型、长度等有关，属于未命名类型。
  
  具有相同声明的未命名类型被视为同一类型。
  
  • 具有相同基类型的指针。
  • 具有相同元素类型和长度的 array。
  • 具有相同元素类型的 slice。
  • 具有相同键值类型的 map。
  • 具有相同元素类型和传送方向的 channel。
  • 具有相同字段序列 (字段名、类型、标签、顺序) 的匿名 struct。 
  • 签名相同 (参数和返回值，不包括参数名称) 的 function。
  • 方法集相同 ( 方法名、方法签名相同，和次序无关) 的 interface。

• struct 特点：

  1. 用来自定义复杂数据结构
  2. struct里面可以包含多个字段（属性）
  3. struct类型可以定义方法，注意和函数的区分
  4. struct类型是值类型
  5. struct类型可以嵌套
  6. Go语言没有class类型，只有struct类型
  7. 结构体是用户单独定义的类型，不能和其他类型进行强制转换
  8. golang中的struct没有构造函数，一般可以使用工厂模式来解决这个问题。
  9. 我们可以为struct中的每个字段，写上一个tag。这个tag可以通过反射的机制获取到，最常用的场景就是json序列化和反序列化。

• 可以理解为面向对象编程

  struct声明及初始化：
  
  声明：
  
  type typeName struct {  
  //...  
  }  
  
  eg:
  package main
  
  type global struct{}
  
  func main() {
      type local struct{}
  }
  
  初始化：
  
  方法有几种：
  
  package main
  
  import (
      "fmt"
  )
  
  type Test struct {
      int
      string
  }
  
  var a Test
  
  func main() {
  
      b := new(Test) //同 var b *Test = new(Test)
      c := Test{1, "c"}
      d := Test{}
      e := &Test{}
      f := &Test{2, "f"} //同 var d *Test = &Test{2, "f"}
  
      fmt.Println(a, b, c, d, e, f)
      // 注: a b c d 返回 Test 类型变量；e f 返回 *Test 类型变量；若无初始化值，则默认为零值
  
  }
  输出结果：
  
  {0 } &{0 } {1 c} {0 } &{0 } &{2 f}

• 初始化值可以分为两种

  a. 有序: typeName{value1, value2, ...} 必须一一对应
  b. 无序: typeName{field1:value1, field2:value2, ...} 可初始化部分值
  
  栗子：
  
  a：有序
  
  type Person struct {
      name string
      age int
      sex int
      phone int
  }
  
  func main() {
      person := Person{"lff", 23, 1, 18135479521}
      fmt.Println(person)
  }
  
  b： 无序
  func main() {
      p2 := Person{age: 23} //无序，指你可以指定给p2赋哪个字段的值
      fmt.Println(person)
  }

• 操作 struct

  声明的struct与普通类型一样
  访问结构体中的一个变量名, 用 "." 来连接:
  varName.field 或 (*varName).field
  如操作上面 Person 结构体中的 age : p.age = 35
  也可以作为函数中的参数，返回值类型

  举个栗子：
  package main
  
  import "fmt"
  
  //1. 声明一个自定义类型名为 Person 的结构体
  type Person struct {
      name string
      age  int
  }
  
  func main() {
      //2. 初始化
      var p1 Person
      p2 := Person{}
      p3 := Person{"James", 23}
      p4 := Person{age: 23}
      fmt.Println(p1, p2, p3, p4)
      p5 := new(Person)
      p6 := &Person{}
      p7 := &Person{"James", 23}
      p8 := &Person{age: 23}
      fmt.Println(p5, p6, p7, p8)
  
      //3. 操作
      p1.age = 50
      p2.age = 25
      if compareAge(p1, p2) {
          fmt.Println("p1 is older than p2")
      } else {
          fmt.Println("p2 is older than p1")
      }
  }
  
  func compareAge(p1, p2 Person) bool {
      if p1.age > p2.age {
          return true
      }
      return false
  }
  输出：
  
  { 0} { 0} {James 23} { 23}
  &{ 0} &{ 0} &{James 23} &{ 23}
  p1 is older than p2

• 匿名字段

  匿名字段：
  声明一个 struct1 可以包含已经存在的 struct2 或者go语言中内置类型作为内置字段，称为匿名字段，即只写了 typeName，无 varName，但是 typeName 不能重复。
  
  匿名字段与面向对象程序语言中的继承
  
  声明及初始化:
  
  package main
  
  import (
      "fmt"
  )
  
  type Person struct {
      name string
      age  int
      addr string
  }
  
  type Employee struct {
      Person //匿名字段
      salary int
      int           //用内置类型作为匿名字段
      addr   string //类似于重载
  }
  
  func main() {
      em1 := Employee{Person{"rain", 23, "qingyangqu"}, 5000, 100, "gaoxingqu"}
  
      fmt.Println(em1)
      // var em2 Person = em1
      // Error: cannot use em1 (type Employee) as type Person in assignment （没有继承， 然也不会有多态）
  
      var em2 Person = em1.Person // 同类型拷贝。
  
      fmt.Println(em2)
  }
  输出结果：
  
  {{Murphy 23 帝都} 5000 100 北京}
  {Murphy 23 帝都}
  操作
  
  访问方式也是通过 "." 来连接
  相同字段采用最外层优先访问，类似于重载
  em1.addr 访问的是 Employee 中最外层的 addr
  em1.Person.addr 访问的是 Employee 中 Person 中的 addr
  package main
  
  import "fmt"
  
  type Person struct {
      name string
      age  int
      addr string
  }
  
  type Employee struct {
      Person //匿名字段
      salary int
      int           //用内置类型作为匿名字段
      addr   string //类似于重载
  }
  
  func main() {
      /*
      var em1 Employee = Employee{}
      em1.Person = Person{"rain", 23, "帝都"}
      em1.salary = 5000
      em1.int = 100 //使用时注意其意义，此处无
      em1.addr = "北京"
      */
      //em1 := Employee{Person{"rain", 23, "帝都"}, 5000, 100, "北京"}
      //初始化方式不一样，但是结果一样
      em1 := Employee{Person: Person{"Murphy", 23, "帝都"}, salary: 5000, int: 100, addr: "北京"}
      fmt.Println(em1)
  
      fmt.Println("live addr(em1.addr) = ", em1.addr)
      fmt.Println("work addr(em1.Person.addr) = ", em1.Person.addr)
      em1.int = 200 //修改匿名字段的值
  
  }
  输出：
  
  {{Murphy 23 帝都} 5000 100 北京}
  live addr(em1.addr) =  北京
  work addr(em1.Person.addr) =  帝都
  空结构 "节省" 内存， 如用来实现 set 数据结构，或者实现没有 "状态" 只有方法的 "静态类"。
  
  package main
  
  func main() {
      var null struct{}
  
      set := make(map[string]struct{})
      set["a"] = null
  }
  不能同时嵌入某一类型和其指针类型，因为它们名字相同。
  
  package main
  
  type Resource struct {
      id int
  }
  
  type User struct {
      *Resource
      // Resource // Error: duplicate field Resource
      name string
  }
  
  func main() {
      u := User{
          &Resource{1},
          "Administrator",
      }
  
      println(u.id)
      println(u.Resource.id)
  }
  输出结果：
  
  1
  1