go List 使用和遍历时注意的坑

引用的是 container/list
测试的方式如下：
1.定义一个简单的结构体student
2.分别测试值传递和引用传递和遍历的使用方法，以及要注意的坑
3.测试基础类型int的引用传递和遍历的使用方法，以及要注意的坑

student结构体

type student struct {
	name string
}

值传递测试

代码

	// s1 s2为值传递
	s1 := student{name: "test1"}
	s2 := student{name: "test2"}

	// 先通过New初始化一个List
	sList := list.New()
	_ = sList.PushBack(s1)
	_ = sList.PushBack(s2)

	fmt.Printf("s1:%p, s2:%p\n", &s1, &s2)
	// 遍历打印
	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(student) // 值传递直接用类型，此处类型为student结构体
		if !ok {
			fmt.Printf("get student failed\n")
		}
		// element.Value取地址会失败，因为是值传递
		fmt.Printf("student:%v element.Value=%p &element.Value=%p\n", s.name, element.Value, &element.Value)
	}

测试结果

s1:0xc000010230, s2:0xc000010240
student:test1 element.Value=%!p(main.student={test1}) &element.Value=0xc000068198
student:test2 element.Value=%!p(main.student={test2}) &element.Value=0xc0000681c8

结论
element.Value就是插入元素的类型，此例为student结构体，不能取地址，
取地址需要在前面加&，并且和插入元素的地址不一样。
转换element.Value的是否，传入插入元素的类型即可。

引用传递测试

代码

	// s3 s4为引用传递
	sList = list.New()
	s3 := &student{name: "test3"}
	s4 := &student{name: "test4"}

	_ = sList.PushBack(s3)
	_ = sList.PushBack(s4)

	fmt.Printf("s3:%p, s4:%p\n", s3, s4)
	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(*student) // 引用传递结类型前需要加*
		if !ok {
			fmt.Printf("get student failed\n")
		}
		// element.Value取地址成功，等于插入的元素的地址，因为是引用传递
		fmt.Printf("student:%v element.Value=%p\n", s.name, element.Value)
	}

	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(student) // 引用传递结类型前不加*时，返回为空
		if !ok {
			fmt.Printf("get student failed\n")
		}
		fmt.Printf("student:%v element.Value=%p\n", s.name, element.Value)
	}

测试结果

s3:0xc000010290, s4:0xc0000102a0
student:test3 element.Value=0xc000010290
student:test4 element.Value=0xc0000102a0
get student failed
student: element.Value=0xc000010290
get student failed
student: element.Value=0xc0000102a0

结论
element.Value是一个地址，此例为student结构体的引用，能取地址，并且和插入的元素地址一样。
注意:在转换element.Value的时候，需要在类型前加*，此例为student，如果不加，则获取类型的值为空
一般结构体插入list建立使用引用传递，节省内存空间。

基础类型引用传递测试

代码

	// 整型引用传递
	num1 := 1
	num2 := 2

	sList = list.New()
	_ = sList.PushBack(&num1)
	_ = sList.PushBack(&num2)
	for element := sList.Front(); element != nil; element = element.Next() {
		v, ok := element.Value.(*int) // 引用传递类型前需要加*
		if !ok {
			fmt.Printf("get num failed\n")
		}
		fmt.Printf("num:%v %v element.Value=%p\n", v, *v, element.Value) // v是引用，需要*v取值
	}

	for element := sList.Front(); element != nil; element = element.Next() {
		v, ok := element.Value.(int) // 引用传递类型前不加*
		if !ok {
			fmt.Printf("get num failed\n")
		}
		fmt.Printf("num:%v element.Value=%p\n", v, element.Value)
	}

测试结果

num:0xc0000140b8 1 element.Value=0xc0000140b8
num:0xc0000140d0 2 element.Value=0xc0000140d0
get num failed
num:0 element.Value=0xc0000140b8
get num failed
num:0 element.Value=0xc0000140d0

结论
测试结果同student的引用传递。
这里还需要注意一点，想要获取v的值，需要在前面加*，取其值，否则返回的是地址。

一般基础类型插入list建立使用值用传递，取值时不用在前面加*。

完成的代码

package main

import (
	"container/list"
	"fmt"
)

type student struct {
	name string
}

func main() {


	// s1 s2为值传递
	s1 := student{name: "test1"}
	s2 := student{name: "test2"}

	// 先通过New初始化一个List
	sList := list.New()
	_ = sList.PushBack(s1)
	_ = sList.PushBack(s2)

	fmt.Printf("s1:%p, s2:%p\n", &s1, &s2)
	// 遍历打印
	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(student) // 值传递直接用类型，此处类型为student结构体
		if !ok {
			fmt.Printf("get student failed\n")
		}
		// element.Value取地址会失败，因为是值传递
		fmt.Printf("student:%v element.Value=%p &element.Value=%p\n", s.name, element.Value, &element.Value)
	}
	fmt.Printf("\n")

	// s3 s4为引用传递
	sList = list.New()
	s3 := &student{name: "test3"}
	s4 := &student{name: "test4"}

	_ = sList.PushBack(s3)
	_ = sList.PushBack(s4)

	fmt.Printf("s3:%p, s4:%p\n", s3, s4)
	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(*student) // 引用传递结类型前需要加*
		if !ok {
			fmt.Printf("get student failed\n")
		}
		// element.Value取地址成功，等于插入的元素的地址，因为是引用传递
		fmt.Printf("student:%v element.Value=%p\n", s.name, element.Value)
	}

	for element := sList.Front(); element != nil; element = element.Next() {
		s, ok := element.Value.(student) // 引用传递结类型前不加*时，返回为空
		if !ok {
			fmt.Printf("get student failed\n")
		}
		fmt.Printf("student:%v element.Value=%p\n", s.name, element.Value)
	}
	fmt.Printf("\n")

	// 整型引用传递
	num1 := 1
	num2 := 2

	sList = list.New()
	_ = sList.PushBack(&num1)
	_ = sList.PushBack(&num2)
	for element := sList.Front(); element != nil; element = element.Next() {
		v, ok := element.Value.(*int) // 引用传递类型前需要加*
		if !ok {
			fmt.Printf("get num failed\n")
		}
		fmt.Printf("num:%v %v element.Value=%p\n", v, *v, element.Value) // v是引用，需要*v取值
	}

	for element := sList.Front(); element != nil; element = element.Next() {
		v, ok := element.Value.(int) // 引用传递类型前不加*
		if !ok {
			fmt.Printf("get num failed\n")
		}
		fmt.Printf("num:%v element.Value=%p\n", v, element.Value)
	}
}