Go语言基础之结构体（冬日篇）

 前言

成都创新互联专注于双清企业网站建设,响应式网站设计,商城网站建设。双清网站建设公司,为双清等地区提供建站服务。全流程按需网站策划，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务

Hey，大家好呀，我是码农，星期八，这是最后一次了，同样也是Go面向对象的最后一次了。坚持住，一起看看看吧。

结构体继承

说起继承，学过Java，Python的肯定都不陌生，但是Go中，可没有这个东西呐。

那咋办呢???，还是得用结构体来实现。

假装我们都是男孩，喜欢车，那我们就拿车来举例子吧。

车结构体

 
 
 
 
    
  
  
  
  
  1. //车
    2. 
  
  
  
  
  2. type Car struct {
    3. 
  
  
  
  
  3.     Brand  string //车品牌
    4. 
  
  
  
  
  4.     CarNum string //车牌号
    5. 
  
  
  
  
  5.     Tyre   int    //轮胎个数
    6. 
  
  
  
  
  6. }
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. //给车绑定一个方法，说明车的基本信息
    9. 
  
  
  
  
  9. func (this *Car) carInfo() {
    10. 
  
  
  
  
  10.     fmt.Printf("品牌:%s，车牌号:%s，轮胎个数:%d\n"， this.Brand， this.CarNum， this.Tyre)
    11. 
  
  
  
  
  11. }
    12.

宝马车

//宝马车

 
 
 
 
    
  
  
  
  
  1. //宝马车
    2. 
  
  
  
  
  2. type BMWCar struct {
    3. 
  
  
  
  
  3.     //*Car和Car基本没有区别，一个存的是整个结构体，一个存的是结构体地址，用法大同小异
    4. 
  
  
  
  
  4.     *Car //这就表示继承了Car这个结构体
    5. 
  
  
  
  
  5. }
    6.

比亚迪车

 
 
 
 
    
  
  
  
  
  1. //比亚迪车
    2. 
  
  
  
  
  2. type BYDCar struct {
    3. 
  
  
  
  
  3.     *Car
    4. 
  
  
  
  
  4. }
    5.

可能看到这，你会有种熟悉得感觉，这不就是上节课所将的结构体嵌套吗???

这跟继承有毛关系?

其实在Go中，结构体既可以用来存储数据，也可以用来模仿对象的各种操作。

main代码

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.     //一个宝马对象
    3. 
  
  
  
  
  3.     var bmw1 = BMWCar{&Car{
    4. 
  
  
  
  
  4.         Brand:  "宝马x8"，
    5. 
  
  
  
  
  5.         CarNum: "京666"，
    6. 
  
  
  
  
  6.         Tyre:   4，
    7. 
  
  
  
  
  7. }}
    8. 
  
  
  
  
  8.     //一个比亚迪对象
    9. 
  
  
  
  
  9.     var byd1 = BYDCar{&Car{
    10. 
  
  
  
  
  10.         Brand:  "比亚迪L3"，
    11. 
  
  
  
  
  11.         CarNum: "京111"，
    12. 
  
  
  
  
  12.         Tyre:   4，
    13. 
  
  
  
  
  13. }}
    14. 
  
  
  
  
  14.     //因为 BMWCar 和 BYDCar 都继承了Car，所以都有carInfo这个方法
    15. 
  
  
  
  
  15.     bmw1.carInfo()
    16. 
  
  
  
  
  16.     byd1.carInfo()
    17. 
  
  
  
  
  17. }
    18.

执行结果

这就是一个最简单的，面向对象，跟其他语言一样，继承会将所有的属性和方法都继承过来。

序列化

到此为止呢，结构体基本可以告一段落了，基本算是入门了，当然，并没有结束，但是我想大家都累了，换个方向继续玩。

这个东西叫做序列化，什么意思呢，就是像咱们的切片了，map了，结构体了等，这些都是Go的类型。

如果要和其他语言交流，人家可没有这些玩意唉，那怎么办呢???

众多大佬就形成了一个规范，json数据格式，json数据必须是字符串类型。

最外面是'号，键/值对组合中的键名写在前面并用双引号""包裹。

就像这样。

 
 
 
 
    
  
  
  
  
  1. '{"Gender":"男"，"Name":"张三"}'    //'说明这个是字符串，一般打印时不显示
    2.

序列化我们用到的是json模块的Marshal方法。

切片序列化

单独的切片序列化用的很少，但是仍然还是要知道。

示例代码

 
 
 
 
    
  
  
  
  
  1. package main
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. import (
    4. 
  
  
  
  
  4.     "encoding/json"
    5. 
  
  
  
  
  5.     "fmt"
    6. 
  
  
  
  
  6. )
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. type Student struct {
    9. 
  
  
  
  
  9.     Gender string
    10. 
  
  
  
  
  10.     Name   string
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. func main() {
    14. 
  
  
  
  
  14.     var StudentList = []string{"张三"， "李四"}
    15. 
  
  
  
  
  15.     fmt.Printf("StudentList类型:%T\n"， StudentList) //[]string，这是列表类型
    16. 
  
  
  
  
  16.     serializeByte， err := json.Marshal(StudentList)
    17. 
  
  
  
  
  17.     if err != nil {
    18. 
  
  
  
  
  18.         fmt.Println("序列化失败")
    19. 
  
  
  
  
  19.         return
    20. 
  
  
  
  
  20. }
    21. 
  
  
  
  
  21.     var serializeStr = string(serializeByte)
    22. 
  
  
  
  
  22.     fmt.Printf("serializeStr类型:%T\n"， serializeStr) //string，这是字符串类型
    23. 
  
  
  
  
  23.     fmt.Printf("serializeStr值:%v\n"， serializeStr) //["张三"，"李四"]
    24. 
  
  
  
  
  24. }
    25.

第16行代码将切片序列化，但是返回的是[]byte类型，第21行代码将[]byte类型转成字符串。

执行结果

map序列化

字典序列化，就比较有味道了，序列化的是一个标准的json数据格式。

示例代码

 
 
 
 
    
  
  
  
  
  1. package main
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. import (
    4. 
  
  
  
  
  4.     "encoding/json"
    5. 
  
  
  
  
  5.     "fmt"
    6. 
  
  
  
  
  6. )
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. type Student struct {
    9. 
  
  
  
  
  9.     Gender string
    10. 
  
  
  
  
  10.     Name   string
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. func main() {
    14. 
  
  
  
  
  14.     var StudentInfo = map[string]string{
    15. 
  
  
  
  
  15.         "Name":"张三"，
    16. 
  
  
  
  
  16.         "Age":"18"，
    17. 
  
  
  
  
  17.         "Gender":"男"，
    18. 
  
  
  
  
  18. }
    19. 
  
  
  
  
  19.     fmt.Printf("StudentInfo类型:%T\n"，StudentInfo)
    20. 
  
  
  
  
  20.     serializeByte， err := json.Marshal(StudentInfo)
    21. 
  
  
  
  
  21.     if err != nil {
    22. 
  
  
  
  
  22.         fmt.Println("序列化失败")
    23. 
  
  
  
  
  23. }
    24. 
  
  
  
  
  24.     var serializeStr = string(serializeByte)
    25. 
  
  
  
  
  25.     fmt.Printf("serializeStr类型:%T\n"， serializeStr) //string，这是字符串类型
    26. 
  
  
  
  
  26.     fmt.Printf("serializeStr值:%v\n"， serializeStr) //{"Age":"18"，"Gender":"男"，"Name":"张三"}
    27. 
  
  
  
  
  27. }
    28.

执行结果

这个就有点像标准的json格式了。

结构体序列化

结构体代码

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.     Name   string
    3. 
  
  
  
  
  3.     Gender string
    4. 
  
  
  
  
  4.     Age    int
    5. 
  
  
  
  
  5. }
    6.

main

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 = Student{
    3. 
  
  
  
  
  3.     Name:   "张三"，
    4. 
  
  
  
  
  4.     Gender: "男"，
    5. 
  
  
  
  
  5.     Age:    18，
    6. 
  
  
  
  
  6.   }
    7. 
  
  
  
  
  7.   fmt.Printf("StudentInfo类型:%T\n"， s1)
    8. 
  
  
  
  
  8.   serializeByte， err := json.Marshal(s1)
    9. 
  
  
  
  
  9.   if err != nil {
    10. 
  
  
  
  
  10.     fmt.Println("序列化失败")
    11. 
  
  
  
  
  11.   }
    12. 
  
  
  
  
  12.   var serializeStr = string(serializeByte)
    13. 
  
  
  
  
  13.   fmt.Printf("serializeStr类型:%T\n"， serializeStr) //string，这是字符串类型
    14. 
  
  
  
  
  14.   fmt.Printf("serializeStr值:%v\n"， serializeStr)
    15. 
  
  
  
  
  15. }
    16.

执行结果

切片套结构体

一般情况下，这种方式数据格式是用的比较多的。

当然， 还可以切片嵌套map，方法和此方法一样，不做例子了。

示例代码

 
 
 
 
    
  
  
  
  
  1. package main
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. import (
    4. 
  
  
  
  
  4.   "encoding/json"
    5. 
  
  
  
  
  5.   "fmt"
    6. 
  
  
  
  
  6. )
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. type Student struct {
    9. 
  
  
  
  
  9.   Name   string
    10. 
  
  
  
  
  10.   Gender string
    11. 
  
  
  
  
  11.   Age    int
    12. 
  
  
  
  
  12. }
    13. 
  
  
  
  
  13. 
  
  
  
  
  14. func main() {
    15. 
  
  
  
  
  15.   var s1 = Student{
    16. 
  
  
  
  
  16.     Name:   "张三"，
    17. 
  
  
  
  
  17.     Gender: "男"，
    18. 
  
  
  
  
  18.     Age:    18，
    19. 
  
  
  
  
  19.   }
    20. 
  
  
  
  
  20.   var s2 = Student{
    21. 
  
  
  
  
  21.     Name:   "李四"，
    22. 
  
  
  
  
  22.     Gender: "女"，
    23. 
  
  
  
  
  23.     Age:    16，
    24. 
  
  
  
  
  24.   }
    25. 
  
  
  
  
  25.   //一个存放 Student 的列表
    26. 
  
  
  
  
  26.   var studentList = []Student{s1， s2}
    27. 
  
  
  
  
  27.   fmt.Printf("StudentInfo类型:%T\n"， studentList)
    28. 
  
  
  
  
  28.   serializeByte， err := json.Marshal(studentList) //main.Student
    29. 
  
  
  
  
  29.   if err != nil {
    30. 
  
  
  
  
  30.     fmt.Println("序列化失败")
    31. 
  
  
  
  
  31.   }
    32. 
  
  
  
  
  32.   var serializeStr = string(serializeByte)
    33. 
  
  
  
  
  33.   fmt.Printf("serializeStr类型:%T\n"， serializeStr) //string，这是字符串类型
    34. 
  
  
  
  
  34.   fmt.Printf("serializeStr值:%v\n"， serializeStr)  
    35. 
  
  
  
  
  35. }
    36.

执行结果

结构体标签(Tag)

Tag可以理解为结构体的说明，由一对反引号包裹起来。

但是一般情况下，Tag在序列化是用的比较多。

结构体代码

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.   Name   string `json:"name"`
    3. 
  
  
  
  
  3.   Gender string `json:"gender"`
    4. 
  
  
  
  
  4.   Age    int    `json:"age"`
    5. 
  
  
  
  
  5. }
    6.

每个字段后面跟的，就是Tag，一定不要把格式搞错啦。

main代码

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 = Student{
    3. 
  
  
  
  
  3.     Name:   "张三"，
    4. 
  
  
  
  
  4.     Gender: "男"，
    5. 
  
  
  
  
  5.     Age:    18，
    6. 
  
  
  
  
  6.   }
    7. 
  
  
  
  
  7.   fmt.Printf("StudentInfo类型:%T\n"， s1)
    8. 
  
  
  
  
  8.   serializeByte， err := json.Marshal(s1) //main.Student
    9. 
  
  
  
  
  9.   if err != nil {
    10. 
  
  
  
  
  10.     fmt.Println("序列化失败")
    11. 
  
  
  
  
  11.   }
    12. 
  
  
  
  
  12.   var serializeStr = string(serializeByte)
    13. 
  
  
  
  
  13.   fmt.Printf("serializeStr类型:%T\n"， serializeStr) //string，这是字符串类型
    14. 
  
  
  
  
  14.   fmt.Printf("serializeStr值:%v\n"， serializeStr)  
    15. 
  
  
  
  
  15. }
    16.

执行结果

可以发现key成小写的了，这就说明一个问题。

在序列化时，如果结构体有json这个Tag，序列化时就会以jsonTag为准，如果没有jsonTag，则以结构体字段为准。

总结

上述我们学习了Go基础之结构体的结构体继承，序列化，结构体标签。学完Go的结构体，可能你也知道了在Go中是如何模仿面向对象了。

一定记得多多实践，多多敲代码。如果在操作过程中有任何问题，记得下面讨论区留言，我们看到会第一时间解决问题。

我是码农星期八，如果觉得还不错，记得动手点赞一下哈。感谢你的观看。

本文转载自微信公众号「Go语言进阶学习」，可以通过以下二维码关注。转载本文请联系Go语言进阶学习公众号。

本文名称：Go语言基础之结构体（冬日篇）
网址分享：http://www.shufengxianlan.com/qtweb/news40/541990.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

同城分类信息

达州网站建设　　 　成都光华机房服务器托管　　 　腾讯香港虚拟主机　　 　小谭网创广告　　 　等级保护测评　　 　成都光华电信机房　　 　成都网站建设　　 　德阳机房托管　　 　自贡网站建设　　 　网站定制　　 　域名注册　　 　成都seo优化　　 　成都服务器租赁　　 　成都工装公司　　 　成都网站设计　　 　交互设计　　 　温江电信机房　　 　高端网站定制　　 　自适应网站设计　　 　消防工程