如何掌握Go语言结构体，有哪些要点和方法

时间2024-03-26 09:14:03发布访客分类其他后端知识浏览1113

导读：在实际案例的操作过程中，我们可能会遇到“如何掌握Go语言结构体，有哪些要点和方法”这样的问题，那么我们该如何处理和解决这样的情况呢？这篇小编就给大家总结了一些方法，具有一定的借鉴价值，希望对大家有所帮助，接下来就让小编带领大家一起了解看看吧...

在实际案例的操作过程中，我们可能会遇到“如何掌握Go语言结构体，有哪些要点和方法”这样的问题，那么我们该如何处理和解决这样的情况呢？这篇小编就给大家总结了一些方法，具有一定的借鉴价值，希望对大家有所帮助，接下来就让小编带领大家一起了解看看吧。

一、结构体

结构体是一系列属性的集合（类似于 Python 中的类）

1、结构体的定义与使用

// 定义
type Person struct {

   Name string
   Age int
   Sex string
}


func main() {

   // 使用
   var per Person
   per.Name="XiaoYang"
   fmt.Println(per)
}

2、定义并赋初值

type Person struct {

   Name string
   Age  int
   Sex  string
}


func main() {

   var per1 Person = Person{
Name: "XiaoYang"}
         // 按关键字传参，可以少传
   var per2 Person = Person{
"Bob", 20, "男"}
  // 按位置传参，全传

   fmt.Println(per1) // 输出：{
XiaoYang 0 }

   fmt.Println(per2) // 输出：{
Bob 20 男}

}

3、匿名结构体（只使用一次，没有名字）

// 定义个匿名结构体并实例化之后赋值给了 hobby 变量
hobby := struct {

   HobbyId   int
   HobbyName string
}
{
HobbyId: 1, HobbyName: "篮球"}


fmt.Println(hobby)  // 输出：{
1 篮球}

fmt.Println(hobby.HobbyName) // 输出：篮球

4、结构体的零值

定义好的结构体没有被初始化时，该结构体的字段将默认赋值为零值

也就是我属性的零值，所以他是值类型，参数传递，copy 传递，在函数中修改不会影响原来的

type Person struct {

   Name string
   Age  int
   Sex  string
}


func main() {

   var per Person=Person{
"Bob", 20, "男"}

    
   fmt.Println(per) // 输出：{
Bob 20 男}

   test(per)  // 输出：{
Bob 20 男}

   fmt.Println(per) // 输出：{
Bob 20 男}

}


func test(per Person)  {

   per.Age=20
   fmt.Println(per)
}

5、结构体的指针

// &
 放在变量前，表示取该变量的地址
// * 放在类型前，表示指向该类型的指针（变量定义，指定类型时才会用到） *[3]int  和 [3]*int
// * 放在变量前，表示解引用（取出指针指向的具体的值）


type Person struct {

 Name string
 Age  int
 Sex  string
}


func main() {
    
 var per1 *Person
 fmt.Println(per1) // 输出：nil>
      表示指针类型

 // 定义并初始化
 var per2 *Person = &
Person{
}
    
 fmt.Println(per2) // 输出：&
{
 0 }
    
    
 // 把per2的名字改成XiaoYang
 (*per2).Name = "XiaoYang"
    
 // 也支持直接使用
 per2.Name = "Bob"
 fmt.Println(per2) // 输出：&
{
Bob 0 }


}

6、匿名字段（字段没有名字，只有类型）

可用于【变量提升 / 提升字段】类似于面向对象的继承

// 定义一个结构体，匿名字段类型就是字段名字，所有类型不能重复
type Person struct {

   string
   int
   Sex  string
}


func main() {

   per := Person{
"XiaoYang", 20, "男"}
 // 字段匿名，类型就是字段名
   fmt.Println(per)   // 输出：{
XiaoYang 20 男}

   fmt.Println(per.string) // 输出：XiaoYang
}

7、嵌套结构体（结构体中套结构体）

type Person struct {

   Name  string
   Age   int
   Sex   string
   Hobby Hobby       // Person中嵌套Hobby结构体字段
}


type Hobby struct {

   HobbyId   int
   HobbyName string
}


func main() {

   per := Person{
Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{
1,"篮球"}
}

    
   fmt.Println(per)  // 输出：{
XiaoYang 20 男 {
1 篮球}
}

   fmt.Println(per.Name) // 输出：XiaoYang
   fmt.Println(per.Hobby.HobbyName) // 输出：篮球
}

8、字段提升

结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段，可以从外部直接访问

type Person struct {

   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名结构体字段
}


type Hobby struct {

   HobbyId   int
   HobbyName string
}


func main() {

   per := Person{
Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{
1,"篮球"}
}

   
   // 打印爱好的名字（Hobby是一个匿名字段，会字段提升）
   fmt.Println(per.HobbyName)   // 输出：篮球
    
   // per.hobby 类似于面向对象中的super()
   fmt.Println(per.Hobby.HobbyName)  // 输出：篮球
}



// ------------------------------------------------------------------------------------


// 当子类和父类中的字段名一样时，就像面向对象的继承，子类继承父类（结构体嵌套，匿名字段），子类可以直接调用父类中的属性或方法

type Person struct {

   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名字段
}


type Hobby struct {

   HobbyId   int
   Name      string
}


func main() {

   per := Person{
Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{
1,"篮球"}
}
    
   
   fmt.Println(per.Name)  // 输出：XiaoYang ——>
    优先使用自己的
   fmt.Println(per.Hobby.Name)  // 输出：篮球    ——>
指定打印Hobby的名字
}

9、结构体相等性

结构体是值类型。

如果它的每一个字段都是可比较的，则该结构体也是可以比较的。

如果两个结构体变量的对应字段相等，则两个变量也是相等的。

如果结构体包含不可比较的字段，则结构体变量也不可比较。

type Person struct {
    
   Name string
   Age  int
   Sex  string
   // 包含不可比较的字段
   Test []int ——>
这是引用类型不可比较
}


func main() {

   // 值类型可以直接==比较，引用类型只能跟nil用==比较
   per1 := Person{
Name: "XiaoYang"}

   per2 := Person{
Name: "XiaoYang"}

   per3 := Person{
Name: "XiaoYang", Age: 20}
    
    
   fmt.Println(per1 == per2)  // 输出：ture ——>
包含不可比较类型都会直接报错
   fmt.Println(per1 == per3)  // 输出：false
}

二、方法

方法就是一个特殊函数，在函数的基础上加了一些东西

在func这个关键字和方法名中间加入一个特殊的接收器类型，接收器可以是结构体类型，也可以是非结构体类型

1、方法的定义和使用

type Person struct {

   Name string
   Age  int
   Sex  string
}


// 定义一个方法：给Person结构体绑定一个方法，oneself（名字随便取）类似于Python类中的self
func (oneself Person) printName()  {

   // 在方法内使用oneself
   fmt.Println(oneself.Name)
}


func main() {

   // 使用，对象调用方法
   per := Person{
}

   per.Name = "XiaoYang"
   // 绑定给对象的方法
   per.printName()       // 输出：XiaoYang
}

2、有了函数为啥还需要方法？

方法功能都能实现，但是呢？它就能指定给某个对象了。

type Person struct {

   Name string
   Age  int
   Sex  string
}


// 方法
func (oneself Person) printName() {

   fmt.Println(oneself.Name)
}


// 函数
func printName(oneself Person)  {

   fmt.Println(oneself.Name)
}


func main() {

   per := Person{
Name: "XiaoYang"}


   per.printName()  // 方法的特殊之处，可以自动传递值
   printName(per)  // 函数需要手动传递值
}

3、指针接收器与值接收器

type Person struct {

   Name string
   Age  int
   Sex  string
}


// 值接收器修改名字
func (oneself Person) changeName(name string) {

   oneself.Name = name
}


// 指针接收器修改年龄
func (oneself *Person) changeAge(age int) {

   oneself.Age = age
}


func main() {

   per := Person{
Name: "XiaoYang", Age: 20}

   fmt.Println(per)  // 输出：{
XiaoYang 20 }


   per.changeName("Bob")// 由于这个是值接收器，它是copy一份传递过去所以修改的是copy的不会改掉原来的
   per.changeAge(18)    // 指针接收器，它传递的是指针

   fmt.Println(per)  // 输出：{
XiaoYang 18 }

}


/*
什么时候用指针接收器，什么时候使用值接收器：
 -想改原来的，就用指针
 -不想改原来的，就用值
*/

5、匿名字段的方法（方法提升）

type Person struct {

   Name  string
   Age   int
   Sex   string
   Hobby // 匿名字段
}


type Hobby struct {

   Id   int
   Name string
}


// 打印Person的名字
func (oneself Person) printName() {

   fmt.Println(oneself.Name)
}


// 打印Hobby的名字
func (oneself Hobby) printHobbyName() {

   fmt.Println(oneself.Name)
}


// 打印Hobby的名字
func (oneself Hobby) printName() {

   fmt.Println(oneself.Name)
}


func main() {

   per := Person{
Name: "XiaoYang", Hobby: Hobby{
1, "篮球"}
}

   per.printName()      // 输出：XiaoYang
   per.printHobbyName() // 输出：篮球

   // 如果方法重名了，优先使用结构体自己的
   per.printName()       // 输出：XiaoYang
   per.Hobby.printName() // 输出：篮球
}

6、在方法中使用值接收器与在函数中使用值参数

type Person struct {

 Name string
 Age  int
 Sex  string
}


// 在方法中使用值接收器
func (oneself Person) printName() {

 fmt.Println(oneself.Name)
}


// 在函数中使用值参数
func printName(oneself Person) {

 fmt.Println(oneself.Name)
}


func main() {
    
 per1 := &
Person{
Name: "XiaoYang"}
 // per1是个指针
 per2 := Person{
Name: "Bob"}
    

 printName(*per1) // 输出：XiaoYang
 per1.printName() // 输出：XiaoYang  ———>
 值收器:可以用值来调，也可以用指针来调
 per2.printName() // 输出：Bob
}

7、在方法中使用指针接收器与在函数中使用指针参数

type Person struct {

   Name string
   Age  int
   Sex  string
}


// 在方法中使用指针接收器
func (oneself *Person) printName() {

   fmt.Println(oneself.Name)
}


func (oneself *Person)changeName(name string)  {

   oneself.Name=name

}


// 在函数中使用指针参数
func printName(oneself *Person) {

   fmt.Println(oneself.Name)
}


func main() {

   per1 := Person{
Name: "XiaoYang"}
     
   per2 := &
Person{
Name: "Bob"}
       // per1是个指针

   per1.printName()   // 值可以调用
   printName(&
per1)

   per2.printName()   // 指针可以调用
   printName(per2)


   per1.changeName("Alen")    // 可以修改
   fmt.Println(per1)

   per2.changeName("YS")     // 可以修改
   fmt.Println(per2)
}

总结：

-不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用。
-不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的。

8、非结构体上绑定方法

不允许在基础数据类型上绑定方法（如：int、string ... )

但是自己定义的类型可以绑定方法

type Myint int

func (i *Myint) add() {

   (*i)++
}


func main() {

   var a Myint = 10
   fmt.Println(a) // 输出：10
   a.add()
   a.add()
   a.add()
   fmt.Println(a) // 输出：13
}

关于“如何掌握Go语言结构体，有哪些要点和方法”的内容就介绍到这，感谢各位的阅读，相信大家对如何掌握Go语言结构体，有哪些要点和方法已经有了进一步的了解。大家如果还想学习更多知识，欢迎关注网络，小编将为大家输出更多高质量的实用文章！

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！

若转载请注明出处：如何掌握Go语言结构体，有哪些要点和方法
本文地址： https://pptw.com/jishu/653402.html

PHP中隐藏后门的技巧你知道多少? 用PHP怎样编写邮箱验证激活的功能?