golang学习

Author: StrayCamel247

daidy_logs/2021年3月10日.md

@@ -1,5 +1,13 @@
 ### golang 函数命名前的括号
-下属中的
+[下面描述中的 函数命名前的括号(a *ar)有啥用？](https://blog.csdn.net/xuq09/article/details/88627778)
+
+这意味着 MiraiGoModule 不是一个独立的功能。函数名称前面的括号是Go定义这些函数将在其上运行的对象的方式。所以，本质上ServeHTTP是一个类型处理程序的方法，可以使用类型处理程序的任何对象来调用，比如h。
+
+他们也被称为接收者。这里是定义他们的方法有两种。如果你想修改接收器，使用如下的指针：
+
+这意味着 MiraiGoModule 不是一个独立的功能。函数名称前面的括号是Go定义这些函数将在其上运行的对象的方式。所以，本质上ServeHTTP是一个类型处理程序的方法，可以使用类型处理程序的任何对象来调用，比如h。
+
+他们也被称为接收者。这里是定义他们的方法有两种。如果你想修改接收器，使用如下的指针：
 ```
 func (a *ar) MiraiGoModule() bot.ModuleInfo {
 	return bot.ModuleInfo{
@@ -68,5 +76,5 @@ go 1.15
 
 
 ```
-
+被导入的文件需要加入func ini才会被识别
 通过go.mod里的包名进行相对调用才能成功且本地包的文件夹明明需要和package命名一样

daidy_logs/2021年3月15日.md

@@ -0,0 +1,268 @@
+### 好记性不如烂笔头
+青岛不倒我不倒，雪花不飘我不飘，不要问我多少量，手指大海方向，只要姑娘长的好，一杯雪碧我就倒
+
+### 常量-声明和限制
+在Go的常量定义中，使⽤ const 关键字，并且不能使⽤ := 标识符。
+常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串
+### 变量的声明方法
+var identifier type
+var a int 
+var b = "douyin"
+a := 9, 10
+### 基础数据类型
+go是⼀种强类型语⾔，也就是说⼀旦⼀个变量被指定了某个数据类型，如果不经过强制转化，那
+么它就永远是这个数据类型了。⽐如⼀开始声明变量str的类型是字符串，接着⼜赋给变量str⼀个
+int类型的值，这是不允许的。这时候我们就需要通过类型转化，go中没有隐式类型，只能通过下
+⾯的强类型转换⽅式。 
+valueOfTypeB = typeB(valueOfTypeA) // 同类
+
+只有相同底层类型的变量之间可以进⾏相互转换（如将 int16 类型转换成 int32 类型）
+
+int 和unit可以转换吗
+正数int和unit转换没问题，负数转化成unit因为符号增加一位数
+```
+package main
+
+import "fmt"
+
+func main() {
+	var a int8
+	a = -123
+	println(uint8(a))
+	/*
+	   PS F:\workspace\Leetcode> go run .\main.go
+	   133
+	*/
+	var b int8
+	b = 123
+	println(uint8(b))
+	/*
+	   PS F:\workspace\Leetcode> go run .\main.go
+	   123
+	*/
+	// var s string
+	// s = "123"
+	// println(int(s))
+	/*
+			# command-line-arguments
+		.\main.go:22:13: cannot convert s (type string) to type int
+	*/
+	fmt.Print(string(b))
+	/*
+		PS F:\workspace\Leetcode> go run .\main.go
+	133
+	123
+	{
+	*/
+}
+
+```
+概念
+
+原码表示法规定：用符号位和数值表示带符号数，正数的符号位用“0”表示，负数的符号位用“1”表示，数值部分用二进制形式表示。
+反码表示法规定：正数的反码与原码相同，负数的反码为对该数的原码除符号位外各位取反。
+补码表示法规定：正数的补码与原码相同，负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1.
+正零和负零的补码相同，[+0]补=[-0]补=0000 0000B
+我们来看整数-1在计算机中如何表示。
+
+假设这也是一个int类型，那么：
+1、先取-1的原码：10000000 00000000 00000000 00000001
+2、得反码： 11111111 11111111 11111111 11111110（除符号位按位取反）
+3、得补码：11111111 11111111 11111111 11111111
+可见，－1在计算机里用二进制表达就是全1。16进制为：0xFFFFFF
+————————————————
+版权声明：本文为CSDN博主「storm_fury」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+原文链接：https://blog.csdn.net/weixin_43215250/article/details/84193451
+
+问题：-1的在计算机读取的时候不是读的0xFFFFFF么，那一个正数16777215的二进制值也是0xFFFFFF；；他俩在计算机存储的时候是一样的吗
+
+### New 和 Make
+new 和 make 是go内建的两个函数，是⽤来创建并分配变量的内存地址。它们的区别在于new
+⼀般是给基本数据类型申请内存，⼀般很少⽤。make是给slice、map和channel申请内存，它返
+回的是对应的这三个类型本身。
+
+常用make
+- slice定义
+    - var identifier []type
+    - var slice1 []type = make([]type, len) 也可以简写为 slice1 := make([]type, len)
+    - 切片初始化 s :=[] int {1,2,3 } 
+    - 通过arr数组对切片初始化 s := arr[:] ；s := arr[startIndex:endIndex] ；s := arr[startIndex:] ；s := arr[:endIndex] 
+
+切片是可索引的，并且可以由 len() 方法获取长度。
+
+切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。
+
+```
+package main
+
+import "fmt"
+
+func main() {
+   var numbers = make([]int,3,5)
+
+   printSlice(numbers)
+}
+
+func printSlice(x []int){
+   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
+}
+```
+
+一个切片在未初始化之前默认为 nil，长度为 0，
+```
+func main() {
+	var a []int
+	fmt.Printf("a=%t", a == nil)
+	/*
+		a=true
+	*/
+}
+```
+
+### 匿名函数
+匿名函数（匿名函数因为没有函数名，所以没办法像普通函数那样调⽤，所以匿名函数需要保存到某个变量或者作为⽴即执⾏函数)
+```
+console := bufio.NewReader(os.Stdin)
+	readLine := func() (str string) {
+		str, _ = console.ReadString('\n')
+		return
+	}
+```
+### Defer
+defer 每操作一个函数，函数都会按照先进后出，后进先出的顺序进行运行
+
+defer 表示延时推迟的意思，在go语⾔中⽤来延时⼀个函数或者⽅法的执⾏。如果⼀个函数或者
+⽅法添加了defer关键字，表示则暂时不执⾏，等到主函数的所有⽅法都执⾏完后才开始执⾏。
+当多个函数被defer的时候他们被添加到⼀个堆栈中，并且根据先进后出的原则执⾏。 即 Last
+In First Out（LIFO）
+由于 defer 语句延迟调⽤的特性，所以 defer 语句能⾮常⽅便的处理资源释放问题。⽐如：资
+源清理、⽂件关闭、解锁及记录时间等。
+
+在Go语⾔的函数中 return 语句在底层并不是原⼦操作，它分为给返回值赋值和RET指令两步。
+⽽ defer 语句执⾏的时机就在返回值赋值操作后，RET指令执⾏前
+
+```
+func test() {
+	println("testing")
+}
+func main() {
+	var a []int
+	fmt.Println(a == nil)
+	defer test()
+	return
+	/*
+		PS F:\workspace\Leetcode> go run .\main.go
+        true
+        testing
+	*/
+}
+```
+
+### 函数值传递-传递时会改变参数的地址/指针不改变
+单传的传参是不改变指针地址的
+```
+func main() {
+	var a int
+	a = 1
+	println(a)
+	ip := &a
+	println(ip)
+	print(fmt.Sprintln("初始%p", &ip))
+	change(ip)
+	println(ip)
+	print(fmt.Sprintln("改变后%p", &ip))
+}
+func change(x *int) {
+	print(fmt.Sprintln("传参%p", x))
+	*x = 1
+}
+
+/*
+1
+0xc0000120b0
+初始%p 0xc000006028
+传参%p 0xc0000120b0
+0xc0000120b0
+改变后%p 0xc000006028
+*/
+
+```
+### 函数值传递-引用与改变
+虽然go函数是值传递，但是传递的参数本身是值还是引⽤，和数据的特点以及类型有关系。这是
+两个概念。
+上⾯介绍了golang的数据类型分为基本类型和复合类型，按照数据特点划分
+值类型： int、float、string、bool、array、struct 。值传递是传递的数值本身，
+不是内存地址。是将数据本身拷⻉⼀份传给函数，本身不受影响。
+引⽤类型: slice、pointer、map、chan 等都是引⽤类型。因为存储的是内存地址，所以
+传递的时候是传递了内存地址。
+
+
+int、float、string、bool、array、struct 举例
+```
+func main() {
+	var a int
+	a = 1
+	change(a)
+	print(a)
+}
+func change(x int) {
+	x = 2
+}
+
+/*
+PS F:\workspace\Leetcode> go run .\main.go
+1
+*/
+
+func main() {
+	var a float32
+	a = 1
+	println(a)
+	change(a)
+	print(a)
+}
+func change(x float32) {
+	x = 2
+}
+
+/*
+PS F:\workspace\Leetcode> go run .\main.go
++1.000000e+000
++1.000000e+000
+*/
+。。。
+```
+
+slice、pointer、map、chan 改变是指其子元素的指向的地址改变了
+```
+import "fmt"
+
+func main() {
+	a := []int{1, 2}
+	fmt.Printf("%+v", a)
+	change(a)
+	fmt.Printf("%+v", a)
+}
+func change(x []int) {
+	x[0] = 22
+}
+
+/*
+PS F:\workspace\Leetcode> go run .\main.go
+[1 2][22 2]
+*/
+```
+其实本身的地址没改变-这和python可变/不可变对象其实很像了
+```
+func main() {
+	a := []int{1, 2}
+	println(&a)
+	fmt.Printf("%+v", a)
+	change(a)
+	println(&a)
+	fmt.Printf("%+v", a)
+}
+func change(x []int) {
+	x[0] = 22
+}
+```

daidy_logs/READMEMD

@@ -1 +1,3 @@
-## 敲代码流水账-记错本
+## 敲代码流水账-记错本
+- 内容为50%的原创50%的复制粘贴
+- 主要目的拱自己回顾知识点使用

main.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []int{1, 2}
+	println(&a)
+	fmt.Printf("%+v", a)
+	change(a)
+	println(&a)
+	fmt.Printf("%+v", a)
+}
+func change(x []int) {
+	x[0] = 22
+}
+
+/*
+PS F:\workspace\Leetcode> go run .\main.go
+[1 2][22 2]
+*/