经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
go学习笔记(2)：数据结构
来源：cnblogs　　作者：骏马金龙　　时间：2018/10/23 9:22:29　　对本文有异议

Go语言不是一门面向对象的语言，没有对象和继承，也没有面向对象的多态、重写相关特性。

Go所拥有的是数据结构，它可以关联方法。Go也支持简单但高效的组合(Composition)，请搜索面向对象和组合。

虽然Go不支持面向对象，但Go通过定义数据结构的方式，也能实现与Class相似的功能。

一个简单的例子，定义一个Animal数据结构：

  1. type Animal struct {
  2.     name string
  3.     speak string
  4. }

这就像是定义了一个class，有自己的属性。

在稍后，将会介绍如何向这个数据结构中添加方法，就像为类定义方法一样。不过现在，先简单介绍下数据结构。

数据结构的定义和初始化

除了int、string等内置的数据类型，我们可以定义structure来自定义数据类型。

创建数据结构最简单的方式：

  1. bm_horse := Animal{
  2.     name:"baima",
  3.     speak:"neigh",
  4. }

注意，上面最后一个逗号","不能省略，Go会报错，这个逗号有助于我们去扩展这个结构，所以习惯后，这是一个很好的特性。

上面bm_horse := Animal{}中，Animal就像是一个类，这个声明和赋值的操作就像创建了一个Animal类的实例，也就是对象，其中对象名为bm_horse，它是这个实例的唯一标识符。这个对象具有属性name和speak，它们是每个对象所拥有的key，且它们都有自己的值。从面向对象的角度上考虑，这其实很容易理解。

还可以根据Animal数据结构再创建另外一个实例：

  1. hm_horse := Animal{
  2.     name:"heima",
  3.     speak:"neigh",
  4. }

bm_horse和hm_horse都是Animal的实例，根据Animal数据结构创建而来，这两个实例都拥有自己的数据结构。如下图：

从另一种角度上看，bm_horse这个名称其实是这个数据结构的一个引用。再进一步考虑，其实面向对象的类和对象也是一种数据结构，每一个对象的名称(即bm_horse)都是对这种数据结构的引用。关于这一点，在后面介绍指针的时候将非常有助于理解。

以下是两外两种有效的数据结构定义方式：

  1. // 定义空数据结构
  2. bm_horse := Animal{}
  4. // 或者，先定义一部分，再赋值
  5. bm_horse := Animal {name:"baima"}
  6. bm_horse.speak = "neigh"

此外，还可以省略数据结构中的key部分(也就是属性的名称)直接为数据结构中的属性赋值，只不过这时赋的值必须和key的顺序对应。

  1. bm_horse := Animal{"baima","neigh"}

在数据结构的属性数量较少的时候，这种赋值方式也是不错的，但属性数量多了，不建议如此赋值，因为很容易混乱。

访问数据结构的属性

要访问一个数据结构中的属性，如下：

  1. package main
  3. import ("fmt")
  5. func main(){
  6.     
  7.     type Animal struct {
  8.         name string
  9.         speak string
  10.     }
  12.     bm_horse := Animal{"baima","neigh"}
  13.     fmt.Println("name:",bm_horse.name)
  14.     fmt.Println("speak:",bm_horse.speak)
  15. }

前面说过，Animal是一个数据结构的模板(就像类一样)，不是实例，bm_horse才是具体的实例，有自己的数据结构，所以，要访问自己数据结构中的数据，可以通过自己的名称来访问自己的属性：

  1. bm_horse.name
  2. bm_horse.speak

指针

bm_horse := Animal{}表示返回一个数据结构给bm_horse，bm_horse指向这个数据结构，也可以说bm_horse是这个数据结构的引用。

除此，还有另一种赋值方式，比较下两种赋值方式：

  1. bm_horse := Animal{"baima","neigh"}
  2. ref_bm_horse := &Animal{"baima","neigh"}

这两种赋值方式，有何不同？

:=操作符都声明左边的变量，并赋值变量。赋值的内容基本神似：

  • 第一种将整个数据结构赋值给变量bm_horse，bm_horse从此变成Animal的实例；
  • 第二种使用了一个特殊符号&在数据结构前面，它表示返回这个数据结构的引用，也就是这个数据结构的地址，所以ref_bm_horse也指向这个数据结构。

那bm_horse和ref_bm_horse都指向这个数据结构，有什么区别？我打算用perl语言的语法来解释它们的区别，因为C和Go的指针太过"晦涩"。

perl中的引用

在Perl中，一个hash结构使用%符号来表示，例如：

  1. %Animal = (
  2.     name => "baima",
  3.     speak => "neigh",
  4. );

这里的"Animal"表示的是这个hash结构的名称，然后通过%+NAME的方式来引用这个hash数据结构。其实hash结构的名称"Animal"就是这个hash结构的一个引用，表示指向这个hash结构，只不过这个Animal是创建hash结构是就指定好的已命名的引用。

perl中还支持显式地创建一个引用。例如：

  1. $ref_myhash = \%Animal;

%Animal表示的是hash数据结构，加上\表示这个数据结构的一个引用，这个引用指向这个hash数据结构。perl中的引用是一个变量，所以使用$ref_myhash表示。

也就是说，hash结构的名称Animal和$ref_myhash是完全等价的，都是hash结构的引用，也就是指向这个数据结构，也就是指针。所以，%Animal能表示取hash结构的属性，%$ref_myhash也能表示取hash结构的属性，这种从引用取回hash数据结构的方式称为"解除引用"。

另外，$ref_myhash是一个变量类型，而%Animal是一个hash类型。

引用变量可以赋值给另一个引用变量，这样两个引用都将指向同一个数据结构：

  1. $ref_myhash1 = $ref_myhash;

现在，$ref_myhash、$ref_myhash1和Animal都指向同一个数据结构。

Go中的指针：引用

总结下上面perl相关的代码：

  1. %Animal = (
  2.     name => "baima",
  3.     speak => "neigh",
  4. );
  6. $ref_myhash = \%Animal;
  7. $ref_myhash1 = $ref_myhash;

%Animal是hash结构，Animal、$ref_myhash、$ref_myhash1都是这个hash结构的引用。

回到Go语言的数据结构：

  1. bm_horse :=  Animal{}
  2. hm_horse := &Animal{}

这里的Animal{}是一个数据结构，相当于perl中的hash数据结构：

  1. (
  2.     name => "baima",
  3.     speak => "neigh",
  4. )

bm_horse是数据结构的直接赋值对象，它直接表示数据结构，所以它等价于前面perl中的%Animal。而hm_horse是Animal{}数据结构的引用，它等价于perl中的Animal、$ref_myhash、$ref_myhash1。

之所以Go中的指针不好理解，就是因为数据结构bm_horse和引用hm_horse都没有任何额外的标注，看上去都像是一种变量。但其实它们是两种不同的数据类型：一种是数据结构，一种是引用。

Go中的星号"*"

星号有两种用法：

  • x *int表示变量x是一个引用，这个引用指向的目标数据是int类型。更通用的形式是x *TYPE
  • *x表示x是一个引用，*x表示解除这个引用，取回x所指向的数据结构，也就是说这是 一个数据结构，只不过这个数据结构可能是内置数据类型，也可能是自定义的数据结构

x *int的x是一个指向int类型的引用，而&y返回的也是一个引用，所以&y的y如果是int类型的数据，&y可以赋值给x *int的x。

注意，x的数据类型是*int，不是int，虽然x所指向的是数据类型是int。就像前面perl中的引用只是一个变量，而其指向的却是一个hash数据结构一样。

*x代表的是数据结构自身，所以如果为其赋值(如*x = 2)，则新赋的值将直接保存到x指向的数据中。

例如：

  1. package main
  3. import ("fmt")
  5. func main(){
  6.     var a *int
  7.     c := 2
  8.     a = &c
  9.     d := *a
  10.     fmt.Println(*a)   // 输出2
  11.     fmt.Println(d)    // 输出2
  12. }

var a *int定义了一个指向int类型的数据结构的引用。a = &c中，因为&c返回的是一个引用，指向的是数据结构c，c是int类型的数据结构，将其赋值给a，所以a也指向c这个数据结构，也就是说*a的值将等于2。所以d := *a赋值后，d自身是一个int类型的数据结构，其值为2。

Go函数参数传值

Go函数给参数传递值的时候是以复制的方式进行的。

因为复制传值的方式，如果函数的参数是一个数据结构，将直接复制整个数据结构的副本传递给函数，这有两个问题：

  1. 函数内部无法修改传递给函数的原始数据结构，它修改的只是原始数据结构拷贝后的副本
  2. 如果传递的原始数据结构很大，完整地复制出一个副本开销并不小

例如，第一个问题：

  1. package main
  3. import ("fmt")
  5. type Animal struct {
  6.     name string
  7.     weight int
  8. }
  10. func main(){
  11.     bm_horse := Animal{
  12.         name: "baima",
  13.         weight: 60,
  14.     }
  15.     add(bm_horse)
  16.     fmt.Println(bm_horse.weight)
  17. }
  19. func add(a Animal){
  20.     a.weight += 10
  21. }

上面的输出结果仍然为60。add函数用于修改Animal的实例数据结构中的weight属性。当执行add(bm_horse)的时候，bm_horse传递给add()函数，但并不是直接传递给add()函数，而是复制一份bm_horse的副本赋值给add函数的参数a，所以add()中修改的a.weight的属性是bm_horse的副本，而不是直接修改的bm_horse，所以上面的输出结果仍然为60。

为了修改bm_horse所在的数据结构的值，需要使用引用(指针)的方式传值。

只需修改两个地方即可：

  1. package main
  3. import ("fmt")
  5. type Animal struct {
  6.     name string
  7.     weight int
  8. }
  10. func main(){
  11.     bm_horse := &Animal{
  12.         name: "baima",
  13.         weight: 60,
  14.     }
  15.     add(bm_horse)
  16.     fmt.Println(bm_horse.weight)
  17. }
  19. func add(a *Animal){
  20.     a.weight += 10
  21. }

为了修改传递给函数参数的数据结构，这个参数必须是直接指向这个数据结构的。所以使用add(a *Animal)，既然a是一个Animal数据结构的一个实例的引用，所以调用add()的时候，传递给add()中的参数必须是一个Animal数据结构的引用，所以bm_horse的定义语句中使用&符号。

当调用到add(bm_horse)的时候，因为bm_horse是一个引用，所以赋值给函数参数a时，复制的是这个数据结构的引用，使得add能直接修改其外部的数据结构属性。

大多数时候，传递给函数的数据结构都是它们的引用，但极少数时候也有需求直接传递数据结构。

属于数据结构的函数

可以为数据结构定义属于自己的函数。

  1. package main
  2. import ("fmt")
  4. type Animal struct {
  5.     name string
  6.     weight int
  7. }
  9. func (a *Animal) add() {
  10.     a.weight += 10
  11. }
  13. func main() {
  14.     bm_horse := &Animal{"baima",70}
  15.     bm_horse.add()
  16.     fmt.Println(bm_horse.weight)    // 输出80
  17. }

上面的add()函数定义方式func (a *Animal) add(){}，它所表示的就是定义于数据结构Animal上的函数，就像类的实例方法一样，只要是属于这个数据结构的实例，都能直接调用这个函数，正如bm_horse.add()一样。

构造器

面向对象中有构造器(也称为构造方法)，可以根据类构造出类的实例：对象。

Go虽然不支持面向对象，没有构造器的概念，但也具有构造器的功能，毕竟构造器只是一个方法而已。只要一个函数能够根据数据结构返回这个数据结构的一个实例对象，就可以称之为"构造器"。

例如，以下是Animal数据结构的一个构造函数：

  1. func newAnimal(n string,w int) *Animal {
  2.     return &Animal{
  3.         name: n,
  4.         weight: w,
  5.     }
  6. }

以下返回的是非引用类型的数据结构：

  1. func newAnimal(n string,w int) Animal {
  2.     return Animal{
  3.         name: n,
  4.         weigth: w,
  5.     }
  6. }

一般上面的方法类型称为工厂方法，就像工厂一样根据模板不断生成产品。但对于创建数据结构的实例来说，一般还是会采用内置的new()方式。

new函数

尽管Go没有构造器，但Go还有一个内置的new()函数用于为一个数据结构分配内存。其中new(x)等价于&x{}，以下两语句等价：

  1. bm_horse := new(Animal)
  2. bm_horse := &Animal{}

使用哪种方式取决于自己。但如果要进行初始化赋值，一般采用第二种方法，可读性更强：

  1. # 第一种方式
  2. bm_horse := new(Animal)
  3. bm_horse.name = "baima"
  4. bm_horse.weight = 60
  6. # 第二种方式
  7. bm_horse := &Animal{
  8.     name: "baima",
  9.     weight: 60,
  10. }

扩展数据结构的字段

在前面出现的数据结构中的字段数据类型都是简简单单的内置类型：string、int。但数据结构中的字段可以更复杂，例如可以是map、array等，还可以是自定义的数据类型(数据结构)。

例如，将一个指向同类型数据结构的字段添加到数据结构中：

  1. type Animal struct {
  2.     name   string
  3.     weight int
  4.     father *Animal
  5. }

其中在此处的*Animal所表示的数据结构实例很可能是其它的Animal实例对象。

上面定义了father，还可以定义son，sister等等。

例如：

  1. bm_horse := &Animal{
  2.     name: "baima",
  3.     weight: 60,
  4.     father: &Animal{
  5.         name: "hongma",
  6.         weight: 80,
  7.         father: nil,
  8.     },
  9. }

composition

Go语言支持Composition(组合)，它表示的是在一个数据结构中嵌套另一个数据结构的行为。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Animal struct {
  8.     name   string
  9.     weight int
  10. }
  12. type Horse struct {
  13.     *Animal                  // 注意此行
  14.     speak string
  15. }
  17. func (a *Animal) hello() {
  18.     fmt.Println(a.name)
  19.     fmt.Println(a.weight)
  20.     //fmt.Println(a.speak)
  21. }
  23. func main() {
  24.     bm_horse := &Horse{
  25.         Animal: &Animal{        // 注意此行
  26.             name:   "baima",
  27.             weight: 60,
  28.         },
  29.         speak: "neigh",
  30.     }
  31.     bm_horse.hello()
  32. }

上面的Horse数据结构中包含了一行*Animal，表示Animal的数据结构插入到Horse的结构中，这就像是一种面向对象的类继承。注意，没有给该字段显式命名，但可以隐式地访问Horse组合结构中的字段和函数。

另外，在构建Horse实例的时候，必须显式为其指定字段名(尽管数据结构中并没有指定其名称)，且字段的名称必须和数据结构的名称完全相同。

然后调用属于Animal数据结构的hello方法，它只能访问Animal中的属性，所以无法访问speak属性。

很多人认为这种代码共享的方式比面向对象的继承更加健壮。

Go中的重载overload

例如，将上面属于Animal数据结构的hello函数重载为属于Horse数据结构的hello函数：

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Animal struct {
  8.     name   string
  9.     weight int
  10. }
  12. type Horse struct {
  13.     *Animal                  // 注意此行
  14.     speak string
  15. }
  17. func (h *Horse) hello() {
  18.     fmt.Println(h.name)
  19.     fmt.Println(h.weight)
  20.     fmt.Println(h.speak)
  21. }
  23. func main() {
  24.     bm_horse := &Horse{
  25.         Animal: &Animal{       // 注意此行
  26.             name:   "baima",
  27.             weight: 60,
  28.         },
  29.         speak: "neigh",
  30.     }
  31.     bm_horse.hello()
  32. }
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号