之前学习golang的速度过于快，部分内容有点囫囵吞枣的感觉，写gorm过程中有很多违反我常识的地方，我通过复习去修正了我之前认知错误和遗漏的地方。

---

itoa

itoa自增的作用在编辑error code时候作用很大，之前编辑springboot的error code字符时需要额外编辑code码，现在用了itoa是真香了

---

约定

golang语言的作者很喜欢约定俗成的东西，可能他认为很多东西没必要重复声明

• public,protect,private 函数 通过首字母是否大写实现能否调用的效果，内部方法在名前加_
• interval 为内部包，当设为内部包的时候，其他包无法调用
• interface只能在包内调用，其他包实现后无法通过interface去new结构体
• 测试用例以_test.go作为末尾进行实现

当然gorm也有很多约定，等进入gorm时提前总结一下

---

匿名函数

匿名函数作为一个函数或方法内部执行的函数，多了两个额外参数，代表立即执行，例如：

func main() {
	a, b := 1, 2
	func(a int, b int) {
		fmt.Println(a + b)
	}(a, b)
}

此时额外参数接收外部变量立即执行方法

---

循环控制

当管道执行中出现异常时，for select跳出只能跳到for循环，不能跳到for以外。又例如双for 循环，需要一次性跳出去时，java需要添加一个flag或者直接return，这里通过Loop + break进行限制

func main() {
	n := 10
	m := 10
Loop:
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			println(i, j)
			if i == 5 && j == 5 {
				break Loop
			}
		}
	}
}

以上方法可以快速跳出循环

---

结构体

结构体实际作为类进行使用，当我们定义一个结构体时，我们可以通过指定函数对应的接收对象将其认定为指定结构体的方法。

结构体作为接收者，可以通过值引用或者类型引用进行传递，当作为值引用的时候，不会修改原来副本的值，而作为指针传递的时候，会修改原来的副本的值

type Dogs struct {
	numbers int
}

func (d Dogs) Add() {
	d.numbers++
}

func (d *Dogs) RealAdd() {
	d.numbers++
}

func main() {
	dogs := new(Dogs)
	fmt.Println(dogs.numbers)
	dogs.Add()
	fmt.Println(dogs.numbers)
	dogs.RealAdd()
	fmt.Println(dogs.numbers)
}
//0
//0
//1

---

接口

面向对象两个关键的操作在于继承父类和实现接口，现在默认接口作为你的父类，所以通过指定参数名为接口名，传递值或指针为实现接口的结构体，就可以实现指定类型的输入。并且可以直接输入原始的interface{}用于接收所有的类型值。

type Animal interface {
	Walk()
	Bark()
}

type Dog struct {
	name string
	age  int
}

func (d *Dog) Walk() {
	fmt.Printf("%s is Walking...\n", d.name)
}
func (d *Dog) Bark() {
	fmt.Printf("wang wang wang\n")
}

type Cat struct {
	name string
	age  int
}

func (c Cat) Walk() {
	fmt.Printf("%s is Walking...\n", c.name)
}
func (c Cat) Bark() {
	fmt.Printf("miao miao miao\n")
}

func show(animal Animal) {
	animal.Walk()
	animal.Bark()
}

func main() {
	cat := Cat{"cat", 1}
	dog := Dog{"dog", 2}

	show(cat)
	show(&dog)
}

cat的方法接收者是变量，此时cat的方法属于结构体，因此show传入cat

dog的方法接收者是指针，此时dog的方法属于对象，因此show传入dog的地址

---

指针

指针一直是我有所不理解的内容，其实从上大一开始就说的很不明确，指针到底是指带星号的值是指针还是地址是指针，为什么要传递指针，为什么传递指针后不用修改值了，后来导致我直接放弃学c去学java，毕竟java当时还比较火，后面深度学习时用的python也没有指针。

其实我一直是冤枉指针了，其实也不能说是冤枉，可能是因为没有一个好的老师给我指明确到底指针是什么玩意，类似的什么依赖注入，控制反转，可持久化，我听得晕头转向的就很容易迷糊。

闲话少说了，其实指针就是变量内存地址，通过指针，我们可以定位这个值在内存的位置。指针有两种获取方法，当你声明的是一个 intPtr *int的变量时，那么你获取的就是一个指针，当你打印intPtr时就是指针值，当你打印*intPtr时就是值。当你声明num:=0时，&num就是指针。

func main() {
	num := 0
	var intPtr *int
	intPtr = new(int)
	fmt.Println(&num)
	fmt.Println(intPtr)
}
//0x949a058
//0x949a05c

其实传递参数的时候如果传递&num，其实也是传值，但是传递的是内存地址的值，接收的时候参数写为 *num即可获取指针的值，此时两边默认修改的都是内存中的值了，也不需要return了

func setCount(ptr *int) {
	num := *ptr
	num += 1
}

func main() {
	num := 10
	setCount(&num)
	fmt.Println(num)
}

golang指针语法糖

type product struct {
	num int
}

func add(p *product) {
	p.num += 1
	fmt.Println(p)
	fmt.Println(p.num)
}

func main() {
	add(&product{0})
}

当你传递的参数为一个结构体是，如果你想处理结构体中的变量，那么golang会自动解引用，什么意思呢，你传递的为product的地址，即为&product，此时方法接收到也为&product，打印也为&product，但是你修改值的时候，它自动解引用了，即p.num其实是(*p).num,这里要注意

---

依赖注入

wire框架可以做的很好，但是我现在没怎么看，还得练