Tous.fun

切片的指针的作用

gdyios@163.com (tous) — Sun, 13 Feb 2022 11:14:54 +0800

最近看一个仓库的源码时，看到下面addValue1中的“奇怪”写法。我的第一反应是这和addValue2的写法有什么区别吗？slice底层是对数组的操作，为什么还需要再多套一个slice的指针呢？

func addValue1(list *[]int) {
	*list = append(*list, 1, 2, 3, 4)
}

func addValue2(list []int) {
    list = append(list, 1, 2, 3, 4)
}

从写法上来说，肯定有区别，形参一个是切片（指针），一个是切片的指针（指针的指针）。

那么这两种写法从功能上有什么区别吗？先来看看slice扩容的情况：

func main() {
	s1 := make([]int, 0, 1)
	s2 := make([]int, 0, 1)
	addValue1(&s1)
	addValue2(s2)
	fmt.Printf("s1: %v\n", s1)
	fmt.Printf("s2: %v\n", s2)
}

func addValue1(list *[]int) {
	*list = append(*list, 1, 2, 3, 4)
}

func addValue2(list []int) {
	list = append(list, 1, 2, 3, 4)
}

输出结果：

1
2

s1: [1 2 3 4]
s2: []

对于s2来说，addValue中append导致数组扩容，内部开辟新的数组，然而s2还是指向原来的旧数组。所以s2底层的数组没有变化。

再来看看数组没扩容的情况，s2是否能正确获得添加新元素后的数组呢？

func main() {
	s1 := make([]int, 0, 10)
	s2 := make([]int, 0, 10)
	fmt.Printf("%p\n", s2)
	addValue1(&s1)
	addValue2(s2)
	fmt.Printf("s1: %v\n", s1)
	fmt.Printf("s2: %v\n", s2)
}

func addValue1(list *[]int) {
	*list = append(*list, 1, 2, 3, 4)
}

func addValue2(list []int) {
	list = append(list, 1, 2, 3, 4)
}

最终的输出：

1
2

s1: [1 2 3 4]
s2: []

这里我们对s1和s2都初始化了长度为0容量为10的切片，并且addValue函数都是添加了4个元素，并不会扩容，那为什么s1，s2在addValue后打印出的值不同呢？

我们可以看看 s2[:4] 输出什么

func main() {
	s1 := make([]int, 0, 10)
	s2 := make([]int, 0, 10)
	addValue1(&s1)
	addValue2(s2)
	fmt.Printf("s1: %v\n", s1)
	fmt.Printf("s2: %v\n", s2)
	fmt.Printf("s2[0:4]: %v\n", s2[:4])
}

func addValue1(list *[]int) {
	*list = append(*list, 1, 2, 3, 4)
}

func addValue2(list []int) {
	list = append(list, 1, 2, 3, 4)
}

输出结果：

1
2
3

s1: [1 2 3 4]
s2: []
s2[0:4]: [1 2 3 4]

可以看到s2的底层数组是成功添加值了的。

实际上，s2的可视范围还受到len的限制，因为go的函数传参始终是值传递，s2的len始终为0，所以看不到底层数组的变化。如下图所示

函数调用是值传递，函数内部s2’ 是对s2的拷贝，所以函数内部的改动针对s2’，和s2无关。同样append函数之后返回一个新的s2’’，这也是为什么append的返回值必须接收。

综上两种情况：slice扩容与不扩容，都使得外部变量s2不会感知到底层数组的变化，而s1却可以。这就是切片的指针的作用。如下图：

调用addValue(&s1)时，取s1的地址，addValue函数内部s1’ 保存的值是s1的地址。

调用*s1' = append(*s1', 1,2,3,4)时，append会返回一个新切片，这个新切片保存在s1'指向的内存中，即s1的内存中。

指针与结构体的一个细节

gdyios@163.com (tous) — Fri, 11 Feb 2022 11:14:54 +0800

结构体实现接口

一个实例只要实现了一个接口中的全部方法，那么就实现了这个接口。之后，我们就可以利用多态的概念，调用实例实现的接口方法。

接口体实现变量有两种方式：值接收者和指针接收者

我们有一个 Mover 接口和一个 dog 结构体

type Mover interface {
    move()
}

type dog struct {}

值接收者实现接口

func (d dog) move() {
    fmt.Println("狗会动")
}

此时实现接口的是dog类型：

func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
    x.move()
}

从上面的代码中我们可以发现，使用值接收者实现接口之后，不管是dog结构体还是结构体指针*dog类型的变量都可以赋值给该接口变量。因为Go语言中有对指针类型变量求值的语法糖，dog指针fugui内部会自动求值*fugui。

指针接收者实现接口

同样的代码我们再来测试一下使用指针接收者有什么区别：

func (d *dog) move() {
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // error: x不可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
}

此时实现Mover接口的是*dog类型，所以不能给x传入dog类型的wangcai，此时x只能存储*dog类型的值。

Go的零值与空值问题

gdyios@163.com (tous) — Wed, 09 Feb 2022 11:14:54 +0800

问题背景

在 go 中，对于变量声明，即使没有显示的赋初始值，go 也默认给变量赋值，具体的值取决于不同类型对应的零值。本质是 go 中的变量在创建时即分配内存，并且在内存中分配了对应类型的零值。

零值

基本类型

var a int
var b bool
var s string

fmt.Printf("%v", a) // 0
fmt.Printf("%v", b) // false
fmt.Printf("%v", s) // ""

复合类型

var a [4]int
var b []int
var m map[string]int
var p *int
var f func()
var person Person
var c chan int

type Person struct {
	Name string
	age  int
}

fmt.Printf("%v\n", a) // [0 0 0 0]
fmt.Printf("%v\n", b) // [] 
fmt.Printf("%v\n", m) // map[]
fmt.Printf("%v\n", p) // <nil>
fmt.Printf("%v\n", f) // <nil>
fmt.Printf("%v\n", person) <""0>
fmt.Printf("%v\n", c) // <nil>

总结

Type	Zero Value
Integer	0
Floating point	0.0
Boolean	false
String	“”
Array: [4]int	[0 0 0 0]
struct	{field: }
Pointer	nil
Interface	nil
Slice	nil
Map	nil
Channel	nil
Function	nil

如何进行空值判断

基本类型

var a *int
var b *bool
var s *string

if a == nil {
    fmt.Println("空值判断", "a == 0")
}
if b == nil {
    fmt.Println("空值判断", "b == nil")
}
if s == nil {
    fmt.Println("空值判断", "s == nil")
}

复合类型

var a *[4]int
var b []int
var m map[string]int
var p *int
var f func()
var person *Person
var c chan int

type Person struct {
	Name string
	age  int
}

if a == nil {
    fmt.Println("空值判断", "b == nil")
}
if b == nil {
    fmt.Println("空值判断", "b == nil")
}
if m == nil {
    fmt.Println("空值判断", "m == nil")
}
if p == nil {
    fmt.Println("空值判断", "p == nil")
}
if f == nil {
    fmt.Println("空值判断", "f == nil")
}
if person == nil {
    fmt.Println("空值判断", "person == nil")
}
if c == nil {
    fmt.Println("空值判断", "c == nil")
}

总结：

对于值类型，判断空值只能使用值类型的指针变量。因为你无法根据零值判空，因为零值既有可能是程序员赋值，也有可能是初始化赋值。
- 对于数组，var a [4]int。默认创建并初始化，可以直接赋值 a[0] = 1。
- 对于结构体。它是值类型。默认创建并初始化，内部field初始化成对应类型的空值。

对于引用类型，判断空值利用 类型变量 == nil

对于 slice 和 map，创建时没有初始化，赋值之前必须初始化。

var s []int
var m map[string]int

s[0] = 1   // panic
m["0"] = 1 // panic

s = make([]int, 4)
m = make(map[string]int)

s[0] = 1   
m["0"] = 1

区别零值和空值

在变量初始化时，go 自动赋予变量零值(0, false, “”)。

我们来看一个例子体会零值和空值的区别。

按需更新，这里指的是接口设计时，规定传来的字段一定是要更新的字段，不需要更新的字段就不要出现。举个例子：

// PUT /score
{
	"id": 1,
	"name": "张三",
	"score": 100,
	"create_time": "2021-12-12"
}

通过以上json，我们创建一条数据，这时该如何设计更新接口？

// POST /score
{	
	"id": 1,
	"name": "不对，我叫李四",
	"score": 0,
	"create_time": ""
}

如上，假如规定零值字段不更新，只有非零值的字段参与更新。那么，如果用户真的想把score字段更新为0怎么办，实际上，零值和空值就产生了歧义。

// POST /score
{
	"id": 1,
	"name": "我叫李四"
}

所以为了避免歧义，我们规定不更新的字段禁止出现在json中。同样的，在json转为go中的结构体时，我们也只能通过指针来接收：

type UpdateScore struct{
	Id int 
	Name *string
	Score *int
	CreateTime *string
}