Golang on 丸子有记, 记录生活、分享技术，专注于运维架构、运维开发(devops)。

Go学习笔记 - 指针详解

wzdushu@gmail.com (wanzi) — Mon, 22 May 2023 18:22:42 +0800

指针是什么？

在Go语言中，指针是一个变量，它存储了另一个变量的内存地址。因此，指针变量指向的是另一个变量的内存地址，而不是变量本身。

声明指针变量时，需要在变量名前加上 *，表示这是一个指针变量，例如：

`1`	`var p *int`

这表示声明了一个名为 p 的指向整型变量的指针。使用 & 运算符可以取得一个变量的地址，例如：

1
2

x := 10
p := &x

这表示取得变量 x 的地址，并将地址赋给指针变量 p。

使用指针访问变量时，需要使用 * 运算符，它表示解引用操作符，例如：

1
2
3

x := 10
p := &x
fmt.Println(*p)

这表示打印出指针变量 p 指向的变量的值，即变量 x 的值。

除了声明指针变量和获取变量的地址之外，还可以使用 new 函数来创建指针变量。例如，创建一个指向整型变量的指针：

`1`	`p := new(int)`

这将创建一个新的整型变量，并返回它的地址，然后将地址赋给指针变量 p。

指针还可以用于函数参数和返回值，以便在函数调用之间共享数据。

在使用指针时需要小心，因为如果指针指向一个无效的内存地址，程序可能会崩溃或产生不可预测的行为。因此，使用指针时需要确保指针指向的内存地址是有效的。

指针使用场景

通过指针函数传参

指针可以用于函数参数的传递，当一个函数需要修改实参的值时，可以将实参的地址作为形参传递给函数，通过操作指针来达到修改实参的值的目的。例如：

func modify(s *string) {
    *s = "hello, world"
}

func main() {
    s := "hello"
    modify(&s)
    fmt.Println(s) // 输出：hello, world
}

通过指针访问结构体字段

通过指针可以更方便地访问结构体中的字段，特别是当结构体很大时，传递指针比较传递整个结构体更高效。例如：

type Person struct {
    Name string
    Age  int
}

func main() {
    p := &Person{
        Name: "Alice",
        Age:  18,
    }
    p.Name = "Bob"
    fmt.Println(p) // 输出：&{Bob 18}
}

通过指针动态分配内存

通过指针可以在运行时动态地分配内存，比如使用 new() 函数创建一个新的变量并返回它的地址。例如：

func main() {
    p := new(int)
    *p = 42
    fmt.Println(*p) // 输出：42
}

传递变长参数

在Golang中，可以使用指针传递变长参数。这是因为在使用变长参数时，传递的是一个切片（slice），而切片本身就是指向一个数组的指针。这样的操作，可以避免拷贝大量的数据。

例如，考虑以下函数，它接受一个变长参数并将其打印出来：

func printArgs(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

现在，如果要将切片作为参数传递给另一个函数，可以使用指针：

func printArgsPtr(args *[]int) {
    for _, arg := range *args {
        fmt.Println(arg)
    }
}

func main() {
    args := []int{1, 2, 3}
    printArgsPtr(&args)
}

在这个示例中，我们定义了一个新函数printArgsPtr，它使用指针作为参数来接收切片。函数体内，我们使用*args来解引用指针，从而得到实际的切片，并遍历它以打印每个元素。在主函数中，我们创建了一个切片，并将其地址传递给printArgsPtr函数。

需要注意的是，在使用指针传递变长参数时，如果切片为空，则不能传递nil指针，而应该传递一个空的切片。这是因为在Golang中，使用空的切片和nil指针的含义不同,后面我会介绍。

除了上述几个方面，指针在一些特定的场景下也非常有用，比如在处理数据结构时，通过指针可以更高效地操作链表、树等数据结构。但需要注意，过度使用指针可能会导致代码难以维护，需要谨慎使用。

常见空数据类型

在 Go 语言中，有一些空数据类型，包括：

空指针（nil pointer）：指向一个不存在地址的指针，一般用 nil 表示。
空切片（nil slice）：长度为 0 的切片，一般用 nil 表示。
空字典（nil map）：长度为 0 的字典，一般用 nil 表示。
空接口（nil interface）：类型和值均为 nil 的接口，一般用 nil 表示。
空通道（nil channel）：没有分配存储空间的通道，一般用 nil 表示。

nil表示一个空指针，即指针变量未指向任何地址，可以表示指针、接口、map、通道和函数类型的零值，而不能用来表示其他类型的零值，如int、float、bool等

这些空数据类型的定义均为对应类型的零值，其中指针、切片、字典、接口和通道的零值都是 nil，表示这些类型的默认值为 nil，即没有指向任何实际数据的指针、切片、字典、接口和通道。因此在实际使用这些数据类型时，可以将其初始化为零值，也可以显式地赋值为 nil。

例如:

var s []int = nil // 定义一个空切片
var p *int = nil  // 定义一个空指针
var m map[string]int = nil //定义一个空字典
var i interface{} = nil //定义一个空接口
var c chan int = nil //定一个空通道

需要注意，如下几点:

nil不是关键字，而是预定义的标识符。在 Go 中，可以将 nil 赋给任何类型的指针、切片、字典、函数和通道等变量。
空切片和空字典在使用前需要初始化，否则会出现 panic 异常。
空通道需要使用 make 函数初始化后才能使用。
空指针可以直接使用，因为它的值为 nil。
空接口不需要初始化即可直接使用。因为空接口本质上就是一个类型为 interface{} 的变量，它可以接受任何类型的值，包括 nil。所以在使用空接口时，如果没有显式地赋值，它就是一个空接口，可以直接使用。

避免空指针异常

在使用指针类型的变量时，需要进行 nil 检查以避免出现空指针异常。

例如：

整型指针类型

1
2

var p *int
fmt.Println(p == nil) // 输出 true

代码中，p 是一个整型指针类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 p 是否为 nil 来检查它是否为空指针。

整型切片类型

1
2

var s []int
fmt.Println(s == nil) // 输出 true

代码中，s 是一个整型切片类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 s 是否为 nil 来检查它是否为空切片。

字典类型

1
2

var m map[string]int
fmt.Println(m == nil) // 输出 true

代码中，m 是一个字典类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 m 是否为 nil 来检查它是否为空字典。

函数类型

1
2

var f func(int) int
fmt.Println(f == nil) // 输出 true

代码中，f 是一个函数类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 f 是否为 nil 来检查它是否为空函数。

整型通道类型

1
2

var ch chan int
fmt.Println(ch == nil) // 输出 true

代码中，ch 是一个整型通道类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 ch 是否为 nil 来检查它是否为空通道。

最后，特别注意，空数组、空切片和空 map是可以使用 len() 函数求长度，结果都为 0。但是，空指针、空接口、空通道是不能使用 len() 函数求长度，否则会引发运行时错误。

这是因为，在 Go 中，len()函数返回一个值的长度，这个长度是预先定义好的，通常是由编译器计算得出的。空切片、空数组和空字典等类型变量的长度为0，因为它们在内存中已经有了一块空间，所以可以使用len()函数获取它们的长度。

而对于空接口和空通道，它们是不存储数据的，所以它们的长度是没有意义的，因此在使用len()函数时会引发运行时错误。如果要判断它们是否为空，应该使用nil值进行判断。

Go学习笔记 - Go基础知识复习

wzdushu@gmail.com (wanzi) — Fri, 17 Mar 2023 18:22:42 +0800

一、基础知识

1、基本数据类型

值类型：

bool（长度1Byte或1个字节）
byte(1个字节，uint8别名)
rune（4个字节，int32别名，-231~231）
int(32 or 64，长度4或8字节)
int8（长度1字节）、int16（长度2字节）、int32（长度4字节）、int64（长度8字节）
uint(32 or 64，长度4或8字节)
uint8(长度1字节)、uint16(长度4字节)、uint32(长度4字节)、uint64(长度8字节)
float32(长度4字节)、float64(长度8字节)
string     //一串固定长度字符连接起来的序列，底层为byte数组
complex64、complex128（默认）//复数类型
array   //数组（固定长度）
struct  //结构体

引用类型（指针类型）：

1
2
3

slice  //序列数组，默认值nil
map //映射，默认值nil
chan // 管道，默认值nil

2、编码&&字符串

golang默认编码是UTF-8

Unicode：一种全球字符编码标准，可变长编码，实现方式有多种，其目的是为了统一所有文字编码，比如UTF-8、UTF-16等，长度范围为1-4字节，默认英文占1Byte，中文占2Byte；每个字符对应一个十六进制的数字，Unicode字符串长度使用utf8.RuneCountInString()函数获取。
UTF-8：是可变长度字符编码，也是Unicode实现方式之一，英文占1Byte，中文占3Byte，emoji占4Byte。

GO中字符有两种，一种byte，一种rune

byte：是uint8别名，常用来处理ASCII字符，表示ASCII码的一个字符串，[]byte(s)，将s转换为byte数组。
rune：是int32别名，等价于int32类型，通常用于表示一个unicode字符的码点（code point），可以处理一切字符，使用方法为[]rune(s)，将s转换为unicode数组

string：一串固定长度字符连接起来的序列，底层为byte数组，字符串是不可改变的，当字符串只有数字字母，可以转换为[]byte或者[]rune，当有汉字等多字节编码的就必须转换为[]rune，最通用的方法是转换为[]rune(s)

单引号：用来表示byte类型或rune类型，默认是rune类型，单引号里面内容为Ascii码字符，ASCII字符串长度使用len()函数获取；
双引号：表示可以解析字符串字面量，支持转义，但是不能用来引用多行；
反引号：用于创建原生的字符串字面量，不支持任何转义序列，支持多行，多用于书写多行消息、html、正则；

3、内置函数

append  // 用于追加元素到数组、切片中，返回修改后的数组和切片
close   // 主要用于关闭channel
delete // 从map中删除key对应value
panic  // 停止常规goroutine(panic或recover：用于错误处理)
recover // 允许程序定义goroutine的panic动作
real  // 返回complex的实部(complex、real、imag用来创建和操作复数)
imag // 返回complex的虚部
make // 用来分配内存，返回Type本身（只能用于slice、map、channel）
new // 用来分配内存，主要用于分配值类型，比如int、struct，返回指向type的指针。
cap // 用来返回某个类型最大容量，只能用于切片和map
copy // 用来复制连接slice，返回复制的数目
len // 获取长度，比如string、array、slice、map、channel
print、println  // 底层打印函数

二、常用占位符：

占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
%+v     打印结构体时，会添加字段名     Printf("%+v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示            Printf("#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")            %
%t      布尔占位符  true 或 false。   Printf("%t", true)       true
%c      字符占位符，相应Unicode码点所表示的字符 Printf("%c", 0x4E2D)        中
%d      整形占位符，十进制表示               Printf("%d", 0x12)          18
%s      字符串占位符（string类型或[]byte)   Printf("%s", []byte("Go语言"))  Go语言
%p      指针占位符，十六进制表示，前缀 0x     Printf("%p", &people)             0x4f57f0

三、数组&&切片&&map

1、数组

var 数组变量名 [元素数量]类型数组长度必须是常量，一旦定义，长度不能变，数组中的元素是可以变化的

`1`	`var a[5]int`

声明一个长度为5，类型为int的数组

a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
b := a[3:6]
// 8 8
fmt.Println(len(a), cap(a))                        
//值：[3 4 5]，长度：3, 容量：5
fmt.Printf("值：%d，长度：%d, 容量：%d", b, len(b), cap(b))

2、切片

拥有相同类型元素的可变序列，它是基于数组做的一层封装，非常灵活，支持自动扩容，切片是一个引用类型，内部包含地址、长度(len)、容量(cap)

语法：var 切片变量名 []类型

var a []string //声明一个长度为0，类型为字符串切片。
var a[]string{} //声明一个长度为0，类型为字符串，并初始化

var myslice = []string{"北京", "上海", "深圳"}

for i := 0; i < len(myslice); i++ {
   fmt.Println("for循环:", myslice[i])
}

3、map

一种无序，基于key/value的数据结构，go中map是一种引用类型，必须使用make初始化才能使用。

语法: map[keytype]valuetype

map默认初始值为nil，需要使用make()函数进行分配内存，其中cap表示map的容量，该参数虽然不是必须的，获取map容量不能用cap，cap返回的是数组切片分配的空间大小；获取map的容量，可以使用len函数。

userInfo := map[string]string{
   "username": "xiaoli",
   "password": "1234556",
}
for k, v := range userInfo {
   fmt.Println(k, v, len(userInfo))
}

四、指针：

go语言中引用数据类型不仅要声明它，还要为它分配内存，否则我们的值就没发存储；而对于值类型的声明就不用分配内存，因为他们已经默认分配好内存。

指针地址：&a
指针取值：*&a
指针类型：&a --> *int
&取值，*跟进地址取值

new：为类型申请一片内存空间，并返回指针。比如对结构体实例化，返回的是结构体的指针地址

make：只用于chan、map以及、slice的内存创建，而且它的返回类型就是这三个类型本身，而不是他们的指针类型。

五、结构体

go语言里没有类的概念，也没有支持类的继承等面向对象的概念；go语言中主要通过结构体内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

1、结构体实例化方法：

直接赋值(var)、new、键值对实例化

package main

import "fmt"

// 定义一个结构体
type member struct {
	name string
	city string
	age  int
}

func main() {
	var p1 member //直接赋值实例化结构体
	p1.name = "小明"
	p1.city = "beijing"
	p1.age = 32

	var p2 = new(member) // new关键字实例化
	p2.name = "小李"
	p2.city = "shanghai"
	p2.age = 20

	p3 := &member{
		name: "小张",
		city: "shenzhen",
		age:  18,
	} // 键值对实例化
	fmt.Printf("p1=%v \n", p1) // 输出值
	fmt.Printf("p1=%+v \n", p1) //输出结构体，并添加字段名称
	fmt.Printf("p2=%#v \n", p2) // 输出结构体字段并返回语法表示
	fmt.Printf("p3=%#v \n", p3)
}

输出结果：

p1={小明 beijing 32} 
p1={name:小明 city:beijing age:32} 
p2=&main.member{name:"小李", city:"shanghai", age:20} 
p3=&main.member{name:"小张", city:"shenzhen", age:18}

2、结构体方法和接收者

go语言的方法是一种特定类型变量的函数，这种特定类型叫做接收者，接收者的概念类似其他语言this,self等。

语法:

1
2

func (接受者变量，接受者类型)  方法名(参数列表) (返回值) {
}

package main

import "fmt"

// 定义一个结构体
type Person struct {
   name string
   age  int
   city string
}

// 值接收者
func (p Person) printInfo() {
   fmt.Printf("姓名：%s, 年龄：%d, 城市：%s \n", p.name, p.age, p.city)
}

// 指针接收者
func (p *Person) setInfo(name string, age int, city string) {
   p.name = name
   p.age = age
   p.city = city
}

func main() {
   // 实例化结构体
   p1 := Person{
      name: "xiaoming",
      age:  15,
      city: "tianjin",
   }
   p1.printInfo() //姓名：xiaoming, 年龄：15, 城市：tianjin
   p1.setInfo("tiantian", 18, "beijing")
   p1.printInfo() //姓名：tiantian, 年龄：18, 城市：beijing
}