Go基础：指针、Map、结构体

我会带着你远行 2023-07-06 08:59 107阅读 0赞

**目录**

Map

按照指定顺序遍历map

元素为map类型的切片

值为切片类型的map

结构体

类型定义和类型别名的区别

struct

取结构体的地址

结构体没有构造函数，可自己实现

结构体初始化

方式一：通过 var 声明结构体

方式二：使用 new

方式三：使用字面量

几种初始化方式之间的区别

结构体的内存布局

方法和接收者

值接收者  VS 指针接收者

结构体的“继承”

封装：结构体字段的可见性

包

带标签的结构体

使用场景

--------------------

# Map #

> **Go语言中的map是引用类型，必须初始化才能使用，**是一种**无序的**基于key-value的数据结构

func main() {
        scoreMap := make(map[string]int, 8)
        scoreMap["张三"] = 90
        scoreMap["小明"] = 100
        fmt.Println(scoreMap)
        fmt.Println(scoreMap["小明"])
        fmt.Printf("type of a:%T\n", scoreMap)
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70][] map也支持在声明的时候填充元素

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 1][]

> Go语言中使用for range遍历map

func main() {
        scoreMap := make(map[string]int)
        scoreMap["张三"] = 90
        scoreMap["小明"] = 100
        scoreMap["王五"] = 60
        for k, v := range scoreMap {
            fmt.Println(k, v)
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 2][]

## 按照指定顺序遍历map ##

func main() {
        rand.Seed(time.Now().UnixNano()) //初始化随机数种子
    
        var scoreMap = make(map[string]int, 200)
    
        for i := 0; i < 100; i++ {
            key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
            value := rand.Intn(100)          //生成0~99的随机整数
            scoreMap[key] = value
        }
        //取出map中的所有key存入切片keys
        var keys = make([]string, 0, 200)
        for key := range scoreMap {
            keys = append(keys, key)
        }
        //对切片进行排序
        sort.Strings(keys)
        //按照排序后的key遍历map
        for _, key := range keys {
            fmt.Println(key, scoreMap[key])
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 3][]

## 元素为map类型的切片 ##

func main() {
        var mapSlice = make([]map[string]string, 3)
        for index, value := range mapSlice {
            fmt.Printf("index:%d value:%v\n", index, value)
        }
        fmt.Println("after init")
        // 对切片中的map元素进行初始化
        mapSlice[0] = make(map[string]string, 10)
        mapSlice[0]["name"] = "王五"
        mapSlice[0]["password"] = "123456"
        mapSlice[0]["address"] = "红旗大街"
        for index, value := range mapSlice {
            fmt.Printf("index:%d value:%v\n", index, value)
        }
    }

## 值为切片类型的map ##

func main() {
        var sliceMap = make(map[string][]string, 3)
        fmt.Println(sliceMap)
        fmt.Println("after init")
        key := "中国"
        value, ok := sliceMap[key]
        if !ok {
            value = make([]string, 0, 2)
        }
        value = append(value, "北京", "上海")
        sliceMap[key] = value
        fmt.Println(sliceMap)
    }

# 结构体  #

> Go语言中**没有“类”的概念，也不支持“类”的继承等面向对象的概念**。
> 
> Go语言中通过**结构体的内嵌**再配合**接口**比面向对象具有更高的扩展性和灵活性。

## 类型定义和类型别名的区别 ##

> 类型别名与类型定义表面上看**只有一个等号的差异**

//类型定义
    type NewInt int
    
    //类型别名
    type MyInt = int
    
    func main() {
        var a NewInt
        var b MyInt
    
        fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
        fmt.Printf("type of b:%T\n", b) //type of b:int
    }

## **struct** ##

> **Go语言中通过struct来实现面向对象**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 4][]

### 取结构体的地址 ###

type student struct {
        name string
        age  int
    }
    
    func main() {
        m := make(map[string]*student)
        stus := []student{
            {name: "pprof.cn", age: 18},
            {name: "测试", age: 23},
            {name: "博客", age: 28},
        }
    
        for _, stu := range stus {
            m[stu.name] = &stu
        }
        for k, v := range m {
            fmt.Println(k, "=>", v.name)
        }
    }

### 结构体没有构造函数，可自己实现 ###

> Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 5][]

func newPerson(name, city string, age int8) *person {
        return &person{
            name: name,
            city: city,
            age:  age,
        }
    }

调用构造函数

p9 := newPerson("pprof.cn", "测试", 90)
    fmt.Printf("%#v\n", p9)

## 结构体初始化 ##

### 方式一：通过 var 声明结构体 ###

在 Go 语言中当一个变量被声明的时候，系统会自动初始化它的默认值，比如 int 被初始化为 0，指针为 nil。  
var 声明同样也会为结构体类型的数据分配内存，所以我们才能像上一段代码中那样，在声明了 `var s T` 之后就能直接给他的字段进行赋值

### 方式二：使用 new ###

使用 new 函数给一个新的结构体变量分配内存，它返回指向已分配内存的指针：var t \*T = new(T)。

type struct1 struct {
        i1 int
        f1 float32
        str string
    }
    
    func main() {
        ms := new(struct1)
        ms.i1 = 10
        ms.f1 = 15.5
        ms.str= "Chris"
    
        fmt.Printf("The int is: %d\n", ms.i1)
        fmt.Printf("The float is: %f\n", ms.f1)
        fmt.Printf("The string is: %s\n", ms.str)
        fmt.Println(ms)
    }

与面向对象语言相同，使用点操作符可以给字段赋值：`structname.fieldname = value`。  
同样的，使用点操作符可以获取结构体字段的值：`structname.fieldname`。

### 方式三：使用字面量 ###

type Person struct {
        name string
        age int
        address string
    }
    
    func main() {
        var p1 Person
        p1 = Person{"lisi", 30, "shanghai"}   //方式A
        p2 := Person{address:"beijing", age:25, name:"wangwu"} //方式B
        p3 := Person{address:"NewYork"} //方式C
    }

在（方式A）中，值必须以字段在结构体定义时的顺序给出。（方式B）是在值前面加上了字段名和冒号，这种方式下值的顺序不必一致，并且某些字段还可以被忽略掉，就想（方式C）那样。  
除了上面这三种方式外，还有一种初始化结构体实体更简短和常用的方式，如下：

ms := &Person{"name", 20, "bj"}
    ms2 := &Person{name:"zhangsan"}

`&Person{a, b, c}` 是一种简写，底层仍会调用 `new()`，这里值的顺序必须按照字段顺序来写，同样它也可以使用在值前面加上字段名和冒号的写法（见上文的方式B，C）。

表达式 `new(Type)` 和 `&Type{}` 是等价的。

## 几种初始化方式之间的区别 ##

到目前为止，我们已经了解了三种初始化结构体的方式：

//第一种，在Go语言中，可以直接以 var 的方式声明结构体即可完成实例化
    var t T
    t.a = 1
    t.b = 2
    
    //第二种，使用 new() 实例化
    t := new(T)
    
    //第三种，使用字面量初始化
    t := T{a, b}
    t := &T{} //等效于 new(T)

使用 `var t T` 会给 t 分配内存，并零值化内存，但是这个时候的 t 的类型是 T  
使用 new 关键字时 `t := new(T)`，变量 t 则是一个指向 T 的指针  
从内存布局上来看，我们就能看出这三种初始化方式的区别：  
使用 var 声明：

![226a71eec123bad5ad05a2751fc8e818.png][]

使用 new 初始化：

![1897c4e2ccceb667d4042407508150b8.png][]

使用结构体字面量初始化：

![945ec32fb11c6e0caab3105c2ee6b05e.png][]

下面来看一个具体的例子

package main
    import "fmt"
    
    type Person struct {
     name string
     age int
    }
    
    func main() {
     var p1 Person
     p1.name = "zhangsan"
     p1.age = 18
     fmt.Printf("This is %s, %d years old\n", p1.name, p1.age)
    
     p2 := new(Person)
     p2.name = "lisi"
     p2.age = 20
     (*p2).age = 23 //这种写法也是合法的
     fmt.Printf("This is %s, %d years old\n", p2.name, p2.age)
    
     p3 := Person{"wangwu", 25}
     fmt.Printf("This is %s, %d years old\n", p3.name, p3.age)
    }

输出：

This is zhangsan, 18 years old
    This is lisi, 23 years old
    This is wangwu, 25 years old

上面例子的第二种情况，虽然 p2 是指针类型，但我们仍然可以像 `p2.age = 23` 这样赋值，不需要像 C++ 中那样使用 `->` 操作符,Go 会自动进行转换。  
注意也可以先通过 `*` 操作符来获取指针所指向的内容，再进行赋值：`(*p2).age = 23`。

## 结构体的内存布局 ##

Go 语言中，结构体和它所包含的数据在内存中是以连续块的形式存在的，即使结构体中嵌套有其他的结构体，这在性能上带来了很大的优势。不像 Java 中的引用类型，一个对象和它里面包含的对象可能会在不同的内存空间中，这点和 Go 语言中的指针很像。下面的例子清晰地说明了这些情况：

type Rect1 struct {Min, Max Point }
    type Rect2 struct {Min, Max *Point }

![09d1dbbd863929528e3cb5cd5b83803a.png][]

### 方法和接收者 ###

> **Go语言中的方法（Method）是一种作用于特定类型变量的函数**。这种**特定类型变量叫做接收者（Receiver）**。接收者的概念就类似于其他语言中的this或者 self。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 6][]

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
            函数体
        }

其中，

>  *  接收者变量：接收者中的参数变量名在命名时，**官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名**。例 如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
>  *  **接收者类型：**接收者类型和参数类似，可以是指针类型和非指针类型。
>  *  方法名、参数列表、返回参数：具体格式与函数定义相同。

举个例子：

//Person 结构体
    type Person struct {
        name string
        age  int8
    }
    
    //NewPerson 构造函数
    func NewPerson(name string, age int8) *Person {
        return &Person{
            name: name,
            age:  age,
        }
    }
    
    //Dream Person做梦的方法
    func (p Person) Dream() {
        fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
    }
    
    func main() {
        p1 := NewPerson("测试", 25)
        p1.Dream()
    }

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 7][]

### 值接收者  VS 指针接收者 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 8][]

>  *  **值接收者 ****是go语言特有**
>  *  **值/指针接收者均可接收值/指针**

## 结构体的“继承” ##

> Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。

//Animal 动物
    type Animal struct {
        name string
    }
    
    func (a *Animal) move() {
        fmt.Printf("%s会动！\n", a.name)
    }
    
    //Dog 狗
    type Dog struct {
        Feet    int8
        *Animal //通过嵌套匿名结构体实现继承
    }
    
    func (d *Dog) wang() {
        fmt.Printf("%s会汪汪汪~\n", d.name)
    }
    
    func main() {
        d1 := &Dog{
            Feet: 4,
            Animal: &Animal{ //注意嵌套的是结构体指针
                name: "乐乐",
            },
        }
        d1.wang() //乐乐会汪汪汪~
        d1.move() //乐乐会动！
    }

## 封装：结构体字段的可见性 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 9][]

> 结构体中字段**大写开头表示可公开访问**，**小写表示私有**（仅在定义当前结构体的包中可访问）。

### 包 ###

>  *  每个目录一个包
>  *  main包包含可执行入口
>  *  为结构定义的方法必须放在同一个包内
>  *  可以是不同文件
> 
> **如何库充系统类型或者别人的类型**
> 
>  *  定义别名
>  *  使用组合

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 10][]

## 带标签的结构体 ##

结构体中的字段除了有名字和类型外，还可以有一个可选的标签（tag）：它是一个附属于字段的字符串，可以是文档或其他的重要标记。

标签的内容不可以在一般的编程中使用，只有包 `reflect` 能获取它。

`reflect` 包，它可以在运行时自省类型、属性和方法，比如：在一个变量上调用 `reflect.TypeOf()` 可以获取变量的正确类型，如果变量是一个结构体类型，就可以通过 Field 来索引结构体的字段，然后就可以使用 Tag 属性。

struct\_tag.go：

package main
    
    import (
        "fmt"
        "reflect"
    )
    
    type TagType struct { // tags
        field1 bool   "An important answer"
        field2 string "The name of the thing"
        field3 int    "How much there are"
    }
    
    func main() {
        tt := TagType{true, "Barak Obama", 1}
        for i := 0; i < 3; i++ {
            refTag(tt, i)
        }
    }
    
    func refTag(tt TagType, ix int) {
        ttType := reflect.TypeOf(tt)
        ixField := ttType.Field(ix)
        fmt.Printf("%v\n", ixField.Tag)
    }

输出：

An important answer
    The name of the thing
    How much there are

###  使用场景 ###

> 结构体中的字段除了有名字和类型外，还可以有一个可选的标签（tag）

使用场景：

> Kubernetes APIServer 对所有资源的定义都用 Json tag 和 protoBuff tag
> 
> NodeName string \`json:"nodeName,omitempty" protobuf:"bytes,10,opt,name=nodeName"\`

package main
    
    import (
    	"reflect"
    )
    
    type MyType struct {
    	Name string `json:"name"`
    }
    
    func main() {
    	mt := MyType{Name: "test"}
    	myType := reflect.TypeOf(mt)
    	name := myType.Field(0)
    	tag := name.Tag.Get("json")
    	println(tag)
    	tb := TypeB{P2: "p2", TypeA: TypeA{P1: "p1"}}
    	//可以直接访问 TypeA.P1
    	println(tb.P1)
    }
    
    type TypeA struct {
    	P1 string
    }
    
    type TypeB struct {
    	P2 string
    	TypeA
    }

参考链接：

[结构体 · Go语言中文文档][_ Go]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200217172700913.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020021717271836.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200217172739213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200217172758317.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020022208525947.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200222085355766.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[226a71eec123bad5ad05a2751fc8e818.png]: https://img-blog.csdnimg.cn/img_convert/226a71eec123bad5ad05a2751fc8e818.png
[1897c4e2ccceb667d4042407508150b8.png]: https://img-blog.csdnimg.cn/img_convert/1897c4e2ccceb667d4042407508150b8.png
[945ec32fb11c6e0caab3105c2ee6b05e.png]: https://img-blog.csdnimg.cn/img_convert/945ec32fb11c6e0caab3105c2ee6b05e.png
[09d1dbbd863929528e3cb5cd5b83803a.png]: https://img-blog.csdnimg.cn/img_convert/09d1dbbd863929528e3cb5cd5b83803a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2020022208542929.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200222085505583.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200222085526685.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200222090557980.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200222091056887.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[_ Go]: http://www.topgoer.com/go%E5%9F%BA%E7%A1%80/%E7%BB%93%E6%9E%84%E4%BD%93.html