备案控制台
探索云世界
开发者社区 云原生 文章 正文

100天精通Golang（基础入门篇）——第18天：深入解析Go语言中的结构体

2023-10-14 39
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 100天精通Golang（基础入门篇）——第18天：深入解析Go语言中的结构体

🌷🍁 博主猫头虎 带您 Go to Golang Language.✨✨🍁

🦄 博客首页——猫头虎的博客🎐

🐳《面试题大全专栏》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺

🌊 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐

🌊 《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~💐

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

摘要

在第18天的学习中，我们将深入探索Go语言中的结构体，这是Go语言中一个非常核心的概念。结构体为我们提供了一种封装多个不同类型数据的方法，是构建复杂数据类型的基础。

引言

结构体，在很多编程语言中都不陌生，它们是用来封装数据的重要工具。而在Go语言中，结构体不仅仅是数据的容器，还与接口、方法等特性紧密结合，展现出强大的功能。

导语

在今天的课程中，我们将从结构体的定义开始，逐步解析其属性、方法绑定以及如何与其他Go语言特性结合使用。你将会看到，通过结构体，Go语言为我们提供了丰富的面向对象编程能力。

一、结构体

1.1 什么是结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

1.2 结构体的定义和初始化

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

一旦定义了结构体类型，它就能用于变量的声明

variable_name := structure_variable_type {value1, value2...valuen}

初始化结构体

// 1.按照顺序提供初始化值
P := person{"Tom", 25}
// 2.通过field:value的方式初始化，这样可以任意顺序
P := person{age:24, name:"Tom"}
// 3.new方式,未设置初始值的，会赋予类型的默认初始值
p := new(person)
p.age=24

1.3 结构体的访问

访问结构体成员(访问结构的各个字段)

通过点.操作符用于访问结构的各个字段。

package main
import "fmt"
type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */
   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407
   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700
   /* 打印 Book1 信息 */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)
   /* 打印 Book2 信息 */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

运行结果：

Book 1 title : Go 语言
Book 1 author : www.runoob.com
Book 1 subject : Go 语言教程
Book 1 book_id : 6495407
Book 2 title : Python 教程
Book 2 author : www.runoob.com
Book 2 subject : Python 语言教程
Book 2 book_id : 6495700

1.4 结构体指针

指针指向一个结构体

也可以创建指向结构的指针。

结构体指针

var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前

struct_pointer = &Book1;

使用结构体指针访问结构体成员，使用 “.” 操作符

struct_pointer.title;
package main
import "fmt"
type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books        /* Declare Book1 of type Book */
   var Book2 Books        /* Declare Book2 of type Book */
   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407
   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700
   /* 打印 Book1 信息 */
   printBook(&Book1)
   /* 打印 Book2 信息 */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

结构体实例化也可以是这样的

package main
import "fmt"
type Books struct {
}
func (s Books) String() string {
  return "data"
}
func main() {
  fmt.Printf("%v\n", Books{})
}

1.5 结构体的匿名字段

结构体的匿名字段

可以用字段来创建结构，这些字段只包含一个没有字段名的类型。这些字段被称为匿名字段。

在类型中，使用不写字段名的方式，使用另一个类型

type Human struct {
    name string
    age int
    weight int
} 
type Student struct {
    Human // 匿名字段，那么默认Student就包含了Human的所有字段
    speciality string
} 
func main() {
    // 我们初始化一个学生
    mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
    // 我们访问相应的字段
    fmt.Println("His name is ", mark.name)
    fmt.Println("His age is ", mark.age)
    fmt.Println("His weight is ", mark.weight)
    fmt.Println("His speciality is ", mark.speciality)
    // 修改对应的备注信息
    mark.speciality = "AI"
    fmt.Println("Mark changed his speciality")
    fmt.Println("His speciality is ", mark.speciality)
    // 修改他的年龄信息
    fmt.Println("Mark become old")
    mark.age = 46
    fmt.Println("His age is", mark.age)
    // 修改他的体重信息
    fmt.Println("Mark is not an athlet anymore")
    mark.weight += 60
    fmt.Println("His weight is", mark.weight)
}

可以使用"."的方式进行调用匿名字段中的属性值

实际就是字段的继承

其中可以将匿名字段理解为字段名和字段类型都是同一个

基于上面的理解，所以可以mark.Human = Human{"Marcus", 55, 220} 和mark.Human.age -= 1

若存在匿名字段中的字段与非匿名字段名字相同，则最外层的优先访问，就近原则

通过匿名访问和修改字段相当的有用，但是不仅仅是struct字段哦，所有的内置类型和自定义类型都是可以作为匿名字段的。

1.6 结构体嵌套

嵌套的结构体

一个结构体可能包含一个字段，而这个字段反过来就是一个结构体。这些结构被称为嵌套结构。

示例代码：

package main
import (  
    "fmt"
)
type Address struct {  
    city, state string
}
type Person struct {  
    name string
    age int
    address Address
}
func main() {  
    var p Person
    p.name = "Naveen"
    p.age = 50
    p.address = Address {
        city: "Chicago",
        state: "Illinois",
    }
    fmt.Println("Name:", p.name)
    fmt.Println("Age:",p.age)
    fmt.Println("City:",p.address.city)
    fmt.Println("State:",p.address.state)
}

1.7 提升字段

在结构体中属于匿名结构体的字段称为提升字段，因为它们可以被访问，就好像它们属于拥有匿名结构字段的结构一样。理解这个定义是相当复杂的。

示例代码：

package main
import (  
    "fmt"
)
type Address struct {  
    city, state string
}
type Person struct {  
    name string
    age  int
    Address
}
func main() {  
    var p Person
    p.name = "Naveen"
    p.age = 50
    p.Address = Address{
        city:  "Chicago",
        state: "Illinois",
    }
    fmt.Println("Name:", p.name)
    fmt.Println("Age:", p.age)
    fmt.Println("City:", p.city) //city is promoted field
    fmt.Println("State:", p.state) //state is promoted field
}

运行结果

Name: Naveen  
Age: 50  
City: Chicago  
State: Illinois

1.8 导出结构体和字段

如果结构体类型以大写字母开头，那么它是一个导出类型，可以从其他包访问它。类似地，如果结构体的字段以大写开头，则可以从其他包访问它们。

示例代码：

1.在computer目录下，创建文件spec.go

package computer
type Spec struct { //exported struct  
    Maker string //exported field
    model string //unexported field
    Price int //exported field
}

2.创建main.go 文件

package main
import "structs/computer"  
import "fmt"
func main() {  
    var spec computer.Spec
    spec.Maker = "apple"
    spec.Price = 50000
    fmt.Println("Spec:", spec)
}

目录结构如下：

src

structs

computer

spec.go

main.go

1.9 结构体比较

结构体是值类型，如果每个字段具有可比性，则是可比较的。如果它们对应的字段相等，则认为两个结构体变量是相等的。

示例代码：

package main
import (  
    "fmt"
)
type name struct {  
    firstName string
    lastName string
}
func main() {  
    name1 := name{"Steve", "Jobs"}
    name2 := name{"Steve", "Jobs"}
    if name1 == name2 {
        fmt.Println("name1 and name2 are equal")
    } else {
        fmt.Println("name1 and name2 are not equal")
    }
    name3 := name{firstName:"Steve", lastName:"Jobs"}
    name4 := name{}
    name4.firstName = "Steve"
    if name3 == name4 {
        fmt.Println("name3 and name4 are equal")
    } else {
        fmt.Println("name3 and name4 are not equal")
    }
}

运行结果

name1 and name2 are equal  
name3 and name4 are not equal

如果结构变量包含的字段是不可比较的，那么结构变量是不可比较的

示例代码：

package main
import (  
    "fmt"
)
type image struct {  
    data map[int]int
}
func main() {  
    image1 := image{data: map[int]int{
        0: 155,
    }}
    image2 := image{data: map[int]int{
        0: 155,
    }}
    if image1 == image2 {
        fmt.Println("image1 and image2 are equal")
    }
}

2.0 结构体作为函数的参数

结构体作为函数参数使用

ackage main
import "fmt"
type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */
   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407
   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700
   /* 打印 Book1 信息 */
   printBook(Book1)
   /* 打印 Book2 信息 */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

make、new操作

make用于内建类型（map、slice 和channel）的内存分配。new用于各种类型的内存分配

内建函数new本质上说跟其它语言中的同名函数功能一样：new(T)分配了零值填充的T类型的内存空间，并且返回其地址，即一个*T类型的值。用Go的术语说，它返回了一个指针，指向新分配的类型T的零值。有一点非常重要：new返回指针

内建函数make(T, args)与new(T)有着不同的功能，make只能创建slice、map和channel，并且返回一个有初始值(非零)的T类型，而不是*T。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个slice，是一个包含指向数据（内部array）的指针、长度和容量的三项描述符；在这些项目被初始化之前，slice为nil。对于slice、map和channel来说，make初始化了内部的数据结构，填充适当的值。

make返回初始化后的（非零）值。

代码案例汇总

  1. 定义结构体:
type Person struct {
    Name string
    Age  int
}
  1. 初始化结构体:
p := Person{Name: "Alice", Age: 25}
  1. 结构体方法绑定:
func (p Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}
  1. 匿名字段和嵌套结构体:
type Contact struct {
    Phone, Address string
}
type PersonWithContact struct {
    Person
    Contact
}
  1. 结构体与接口:
type Speaker interface {
    Speak() string
}
func (p Person) Speak() string {
    return "Hello!"
}

今日学习总结

结构体是Go语言中的重要组成部分，不仅是数据的封装，还与方法、接口紧密结合。通过今天的学习，我们已经掌握了如何定义、初始化结构体，如何给它绑定方法，以及如何与其他特性进行交互。它为我们提供了强大的面向对象编程工具，使得代码组织更加清晰、模块化。

参考资料

  1. Go官方文档：结构体
  2. Go语言圣经：结构体章节

结语

通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。

学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。

在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。

如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。

最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！

期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

如果您在学习过程中有任何疑惑，请点击下方名片，带您一对一快速入门 Go语言 的世界 ~

文章标签：
云解析DNS
Go
存储
开发者
容器
Cloud Native
关键词：
Go语言
Golang语言
Go golang
Golang go
golang Go结构体
猫头虎
目录
相关文章
牵着猫散步的鼠鼠
|
5天前
|
人工智能 Go 调度
掌握Go并发：Go语言并发编程深度解析
掌握Go并发：Go语言并发编程深度解析
牵着猫散步的鼠鼠
17 2
长梦
|
4天前
|
程序员 Go
Golang深入浅出之-Select语句在Go并发编程中的应用
【4月更文挑战第23天】Go语言中的`select`语句是并发编程的关键，用于协调多个通道的读写。它会阻塞直到某个通道操作可行，执行对应的代码块。常见问题包括忘记初始化通道、死锁和忽视`default`分支。要解决这些问题，需确保通道初始化、避免死锁并添加`default`分支以处理无数据可用的情况。理解并妥善处理这些问题能帮助编写更高效、健壮的并发程序。结合使用`context.Context`和定时器等工具，可提升`select`的灵活性和可控性。
长梦
17 2
shark-chili
|
2天前
|
存储 Go
用Go语言实现一个单协程消费者模型
用Go语言实现一个单协程消费者模型
shark-chili
13 0
shark-chili
|
2天前
|
编译器 Go C语言
一文速通Go语言面向对象编程
一文速通Go语言面向对象编程
shark-chili
9 0
shark-chili
|
2天前
|
Java 编译器 Go
一文速通go语言类型系统
一文速通go语言类型系统
shark-chili
8 0
shark-chili
|
2天前
|
存储 Java 编译器
一文快速掌握Go语言切片
一文快速掌握Go语言切片
shark-chili
5 0
shark-chili
|
2天前
|
自然语言处理 安全 Java
速通Go语言编译过程
速通Go语言编译过程
shark-chili
15 0
长梦
|
4天前
|
Go 开发者
Golang深入浅出之-Go语言上下文（context）包：处理取消与超时
【4月更文挑战第23天】Go语言的`context`包提供`Context`接口用于处理任务取消、超时和截止日期。通过传递`Context`对象，开发者能轻松实现复杂控制流。本文解析`context`包特性，讨论常见问题和解决方案，并给出代码示例。关键点包括：1) 确保将`Context`传递给所有相关任务；2) 根据需求选择适当的`Context`创建函数；3) 定期检查`Done()`通道以响应取消请求。正确使用`context`包能提升Go程序的控制流管理效率。
长梦
14 1
长梦
|
5天前
|
安全 Go 开发者
Golang深入浅出之-Go语言并发编程面试：Goroutine简介与创建
【4月更文挑战第22天】Go语言的Goroutine是其并发模型的核心，是一种轻量级线程，能低成本创建和销毁，支持并发和并行执行。创建Goroutine使用`go`关键字，如`go sayHello("Alice")`。常见问题包括忘记使用`go`关键字、不正确处理通道同步和关闭、以及Goroutine泄漏。解决方法包括确保使用`go`启动函数、在发送完数据后关闭通道、设置Goroutine退出条件。理解并掌握这些能帮助开发者编写高效、安全的并发程序。
长梦
13 1
长梦
|
5天前
|
JSON 编译器 Go
Golang深入浅出之-结构体标签（Tags）：JSON序列化与反射应用
【4月更文挑战第22天】Go语言结构体标签用于添加元信息，常用于JSON序列化和ORM框架。本文聚焦JSON序列化和反射应用，讨论了如何使用`json`标签处理敏感字段、实现`omitempty`、自定义字段名和嵌套结构体。同时，通过反射访问标签信息，但应注意反射可能带来的性能问题。正确使用结构体标签能提升代码质量和安全性。
长梦
9 0

热门文章

最新文章

  • 1
    Golang框架实战-KisFlow流式计算框架(1)-概述
  • 2
    通过Golang获取公网IP地址
  • 3
    开发语言详解（python、java、Go(Golong)。。。。）
  • 4
    《Go 简易速速上手小册》第10章：微服务与云原生应用（2024 最新版）（下）
  • 5
    《Go 简易速速上手小册》第1章：Go 语言基础（2024 最新版）（上）
  • 6
    Sublime Text 3配置Go语言开发环境
  • 7
    《Go 简易速速上手小册》第6章：错误处理和测试（2024 最新版）（上）
  • 8
    推荐一款go语言的开源物联网框架-opengw
  • 9
    探索Gin框架：快速构建高性能的Golang Web应用
  • 10
    《Go 简易速速上手小册》第10章：微服务与云原生应用（2024 最新版）（上）
  • 1
    Git 术语解析：深入理解上游分支
    92
  • 2
    敏捷开发：解析灵活而高效的软件开发方法
    47
  • 3
    TiDB适用场景解析：海量数据存储与高并发读写的利器
    289
  • 4
    深入学习 XML 解析器及 DOM 操作技术
    72
  • 5
    Python基础算法解析：支持向量机（SVM）
    35
  • 6
    探索Java并发编程：Fork/Join框架的深度解析
    24
  • 7
    视觉智能平台常见问题之图片解析出的水印图判断是自己添加的水印图如何解决
    22
  • 8
    Java必刷入门递归题×5（内附详细递归解析图）
    22
  • 9
    【进阶C语言】数组笔试题解析
    18
  • 10
    哲学家解析Sora本质，AI视频离世界模拟器还有多远？
    29

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 语言入门-2：基本类型

    • 推荐镜像

    更多
  • golang
  • nodejs-release
  • pypi
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考