Golang基础知识点整理

两种执行流程的方式区别

1. 如果我们先编译生成了可执行文件，那么我们可以将该可执行文件拷贝到没有go开发环境的机器上，仍然可以运行
2. 如果我们是直接go run go 源代码，那么如果要在另外一个机器上这么运行，也需要go开发环境，否则无法执行
3. 在编译时，编译器会将程序运行依赖的库文件包含在可执行文件中，所以，可执行文件变大了很多

程序开发注意事项

1. go源文件以“go”为扩展名
2. go应用程序的执行入口时main()函数
3. go语言严格区分大小写
4. go方法由一条条语句构成，每个语句后不需要分号（go语言会在每行后自动加分号），这也体现出golang的简洁性
5. go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
6. go语言定义的变量或者import的包如果没有使用到，代码不能编译通过
7. 大括号都是成对出现的，缺一不可

程序中"\r"回车的效果

\r 回车，从当前行的最前面开始输出，覆盖掉前面相同长度的内容。

例如：

fmt.Println("hello word\rhhhhh")

输出：

hhhhh word

程序的注释

行注释：// 块注释：/* 注释内容 */

变量使用注意事项

1. 变量表示内存中的一个存 储区域

2. 该区域有自己的名称（变量名）和类型（数据类型）

3. Golang变量使用的三种方式

   1. 第一种：指定变量类型，声明后若不赋值，使用默认值
   2. 第二种：根据值自行判定变量类型（类型推导）
   3. 第三种：省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误

   // “:=”只能在声明“局部变量”的时候使用，而“var”没有这个限制。	
   name := "asdf"
   fmt.Println(name)
   
   a := 100
   b := 12.34
   c := 'c'
   d := ""
   e := false
   
   fmt.Printf("a=%T,b=%T,c=%T,d=%T,e=%T", a, b, c, d, e)
   // a=int,b=float64,c=int32,d=string,e=bool
   

4. 多变量声明

   在编程中，有时我们需要一次性声明多个变量，Golang也提供这样的语法

程序中“+“号的使用

1. 当左右两边都是数值型时，则做加法运算
2. 当左右两边都是字符串，则做字符串拼接

变量的数据类型

• 基本数据类型
  • 数值型
    • 整数类型（int,int16,int32,int64,uint,uint8,uint32,uint64,byte）
    • 浮点类型（float32,float64）
      • float64位的精度，比float32位的精度要高
      • 浮点类型有固定的范围和字段长度，不受具体os（操作系统）的影响
      • 浮点类型默认声明为float64类型
  • 字符型（没有专门的字符型，使用byte来保存单个字母字符）
    • 字符常量是用单引号括起来的单个字符
    • go中允许使用转义字符''来将其后的字符转变为特殊字符型常量
    • go语言的字符使用utf-8编码
    • 在go中，字符的本质是一个整数，直接输出时，是该字符对应的utf-8编码的码值
    • 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符
    • 字符类型是可以进行运算的，相当于一个整数，因为它都对应有unicode码
    • go语言的编码统一成了utf-8编码
  • 布尔型（bool）
    • bool类型占用存储空间是1个字节
    • bool类型只能取true或者false
  • 字符串（string）
    • 字符串就是一串固定长度的字符连接起来的字符序列。go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而go的字符串不同，它是由字节组成的
    • go语言的字符串的字节使用utf-8编码标识unicode文本
    • 字符串一旦赋值了，字符串就不能修改了：在go中字符串是不可变的
    • 字符串的两种表现形式
      • 双引号，会识别转义字符
      • 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
    • 字符串的拼接方式+、+=，当使用+号进行字符串拼接时候，多行处理中，上一行要以+结尾
• 派生/复杂数据类型
  • 指针（Pointer）
  • 数组
  • 结构体（struct）
  • 管道（Channel）
  • 函数（也是一种类型）
  • 切片（slice）
  • 接口（interface）
  • map

整型的类型

类型	有无符号	占用存储空间	表数范围	备注
int8	有	1字节	-128 ~ 127
int16	有	2字节	-$2^{15}$ ~ $2^{15}$ - 1
int32	有	4字节	-$2^{31}$ ~ $2^{31}$ - 1
int64	有	8字节	-$2^{63}$ ~ $2^{63}$ - 1
uint8	无	1字节	0 ~ 255
uint16	无	2字节	0 ~ $2^{16}$ - 1
uint32	无	4字节	0 ~ $2^{32}$ - 1
uint64	无	8字节	0 ~ $2^{64}$ - 1
int	有	32位系统4个字节 64位系统8个字节	-$2^{31}$ ~ $2^{31}$ - 1 -$2^{63}$ ~ $2^{63}$ - 1
uint	无	32位系统4个字节 64位系统8个字节	0 ~ $2^{32}$ - 1 0 ~ $2^{64}$ - 1
rune	有	与int32一样	-$2^{31}$ ~ $2^{31}$ - 1	等价int32表示一个unicode码
byte	无	与uint8一样	0 ~ 255	当要存储字符时选byte

整型的类型

类型	占用存储空间	表数范围
单精度float32	4字节	-3.403E38 ~ 3.403E38
双精度float64	8字节	-1.798E308 ~ 1.798E308

变量的数据类型默认值

package main

import "fmt"

func main() {
	var a int
	var b float32
	var c float64
	var d byte
	var e bool
	var f string

	fmt.Printf("a=%d,b=%f,c=%f,d=%v,e=%t,f=%s", a, b, c, d, e, f)
}

// a=0,b=0.000000,c=0.000000,d=0,e=false,f=

基本数据类型的相互转换

go 在不同类型的变量之间赋值时需要显式转换。也就是说go中数据类型不能自动转换

在转换中，比如将 int64 转成 int8，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样

var a int64 = 999999
var b int8 = int8(a)

fmt.Printf("a=%d,b=%d", a, b)
// a=999999,b=63

package main

func main() {
	var n1 int32 = 12
	var n2 int64
	var n3 int8
	
	n2 = n1 + 20 // 编译不通过，因为n1的数据类型为int32，[n1 + 20]的结果类型也为int32，无法将int32类型的值赋给int64类型的变量
	n3 = n1 + 20 // 编译不通过，因为n1的数据类型为int32，[n1 + 20]的结果类型也为int32，无法将int32类型的值赋给int8类型的变量
}

package main

func main() {
	var n1 int32 = 12
	var n2 int8
	var n3 int8

	n2 = int8(n1) + 127 // 编译通过，但是结果按溢出值处理
	n3 = int8(n1) + 128 // 编译不通过，因为128，直接报范围溢出
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a int8 = 100
	var b float64 = 12.34
	var c byte = 'c'
	var d string = ""
	var e bool = false

	d = fmt.Sprintf("%d,%f,%v,%t", a, b, c, e)
	fmt.Printf("%T:%s\n", d, d)

	d = strconv.FormatInt(int64(a), 10)
	fmt.Printf("%T:%s\n", d, d)

	// Itoa是FormatInt(i, 10) 的简写。
	d = strconv.Itoa(int(a))
	fmt.Printf("%T:%s\n", d, d)

	d = strconv.FormatFloat(b, 'f',10, 64)
	fmt.Printf("%T:%s\n", d, d)

	d = strconv.FormatBool(e)
	fmt.Printf("%T:%s\n", d, d)

	fmt.Println("-------------------")

	var a1 = "100"
	var b1 = "123.234"
	var c1 = "true"
	var c3 = ""
	var c4 = "1"
	var c5 = "0"
	var a2 int64
	var b2 float64
	var c2 bool

	a2, _ = strconv.ParseInt(a1, 10, 64)
	fmt.Printf("%T:%d\n", a2, a2)

	b2, _ = strconv.ParseFloat(b1, 64)
	fmt.Printf("%T:%f\n", b2, b2)

	c2, _ = strconv.ParseBool(c1)
	fmt.Printf("%T:%t\n", c2, c2)
	c2, _ = strconv.ParseBool(c3)
	fmt.Printf("%T:%t\n", c2, c2)
	c2, _ = strconv.ParseBool(c4) 
	fmt.Printf("%T:%t\n", c2, c2)
	c2, _ = strconv.ParseBool(c5)
	fmt.Printf("%T:%t\n", c2, c2)
}

/*
string:100,12.340000,99,false
string:100
string:100
string:12.3400000000
string:false
-------------------
int64:100
float64:123.234000
bool:true
bool:false
bool:true
bool:false
*/

指针

1. 基本数据类型，变量存的就是值，也叫值类型
2. 获取变量的地址，用&
3. 指针的类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
4. 获取指针类型所指向的值，使用*

package main

import "fmt"

func main() {
	var i int = 10
	fmt.Printf("变量i的内存地址为：%v", &i)
	fmt.Printf("\n变量i的值为：%v", i)

	var j *int = &i
	fmt.Printf("\n变量j的内存地址为：%v", &j)
	fmt.Printf("\n变量j的值为：%v", j)
	fmt.Printf("\n变量j的值指向的值为：%v", *j)

	i = 20
	fmt.Println("\n---------------------------")
	fmt.Printf("\n修改变量i后，变量i的内存地址为：%v", &i)
	fmt.Printf("\n修改变量i后，变量i的值为：%v", i)
	fmt.Printf("\n修改变量i后，变量j的内存地址为：%v", &j)
	fmt.Printf("\n修改变量i后，变量j的值为：%v", j)
	fmt.Printf("\n修改变量i后，变量j的值指向的值为：%v", *j)

	*j = 30
	fmt.Println("\n---------------------------")
	fmt.Printf("\n修改变量j后，变量i的内存地址为：%v", &i)
	fmt.Printf("\n修改变量j后，变量i的值为：%v", i)
	fmt.Printf("\n修改变量j后，变量j的内存地址为：%v", &j)
	fmt.Printf("\n修改变量j后，变量j的值为：%v", j)
	fmt.Printf("\n修改变量j后，变量j的值指向的值为：%v", *j)
}

/*
变量i的内存地址为：0xc0000b2008
变量i的值为：10
变量j的内存地址为：0xc0000ac020
变量j的值为：0xc0000b2008
变量j的值指向的值为：10
---------------------------

修改变量i后，变量i的内存地址为：0xc0000b2008
修改变量i后，变量i的值为：20
修改变量i后，变量j的内存地址为：0xc0000ac020
修改变量i后，变量j的值为：0xc0000b2008
修改变量i后，变量j的值指向的值为：20
---------------------------

修改变量j后，变量i的内存地址为：0xc0000b2008
修改变量j后，变量i的值为：30
修改变量j后，变量j的内存地址为：0xc0000ac020
修改变量j后，变量j的值为：0xc0000b2008
修改变量j后，变量j的值指向的值为：30
*/

值类型和引用类型

• 值类型

  • 基本数据类型int系列，float系列，bool，string，数组和结构体struct
  • 变量直接存储值，内存通常在栈中分配

• 引用类型

  • 指针，slice切片，map，管道chan，interface等都是引用类型
  • 变量存储的是一个地址，这个地址对应的空间才真正存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收

标识符

• 概念
  • go 对各种变量、方法、函数等命名时使用的字符序列称为标识符
  • 凡是自己可以起名字的地方都叫标识符
• 命名规则
  • 由26个英文字母大小写，0-9，_组成
  • 数字不可以开头
  • 严格区分大小写
  • 标识符不能包含空格
  • 下划线_本身在go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略（比如：忽略某个返回值）。所以仅能被作为占位符使用，不能作为标识符使用。
  • 不能以系统保留关键字作为标识符，比如 break 、if 等等
• 注意事项
  • 包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，和标准库不要冲突
  • 变量名、函数名、常量名：采用驼峰法
  • 如果变量名、函 数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（注：可以简单的理解成，首字母大写是公有的，首字母小写的是私有的）

运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	-4	-4
+	加	5 + 5	10
-	减	6 - 4	2
*	乘	3 * 4	12
/	除	5 / 5	1
%	取模	7 % 5	2
++	自增	a=2 a++	a=3
--	自减	a=2 a--	a=1
+	字符串相加	"He" + "llo"	"Hello"

package main

import (
	"fmt"
)

func main() {
	// 如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Println(10 / 4) // 结果，2
	var n1 float32 = 10 / 4 // 结果，2
	fmt.Println(n1)

	// 如果希望保留小数部分，则需要有浮点数参与运算
	var n2 float32 = 10.0 / 4
	fmt.Println(10.0 / 3) // 结果，3.3333333333333335
	fmt.Println(n2) // 结果，2.5

	// 取模公式：a % b = a - a / b * b
	fmt.Println(10 % 3)

	var i int = 1
	i++
	fmt.Println(i)
	i++
	fmt.Println(i)
	// 下面的语言使用方式错误，++、--只能独立使用，无法直接使用到表达式中
	//var j int = i++
	//var k int = i--
	// 下面的语言使用方式错误，不允许前++、--
	//++i
	//--i
}

关系运算符

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

逻辑运算符

假定 A 值为 true，B 值为 false

运算符	描述	实例
&&	逻辑与运算符。如果两边的操作数都是true，则为true，否则false	(A&&B) 为false
||	逻辑或运算符。如果两边的操作数有一个true，则为true，否则为false	(A||B) 为true
!	逻辑非运算符。如果条件为true，则逻辑为false，否则true	!(A&&B) 为true

• &&也叫短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false
• ||也叫短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C = A + B 将 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 等于 C = C + A
-=	相减后再赋值	C -= A 等于 C = C - A
*=	相乘后再赋值	C *= A 等于 C = C * A
/=	相除后再赋值	C /= A 等于 C = C / A
%=	求余后再赋值	C %= A 等于 C = C % A
<<=	左移后赋值	C <<= A 等于 C = C << A
>>=	右移后赋值	C >>= A 等于 C = C >> A
&=	按位与后赋值	C &= A 等于 C = C & A
^=	按位异或后赋值	C ^= A 等于 C = C ^ A
|=	按位或后赋值	C |= A 等于 C = C | A

分支控制

• 单分支

  • Go 的 if 还有一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了

  package main
  
  import "fmt"
  
  func main() {
  	if age := 20; age > 18 {
  		fmt.Println("ok")
  		fmt.Println(age)
  		age1 := 22
  		fmt.Println(age1)
  	}
  	//fmt.Println(age) // 报错，不可引用if中定义的变量
  	//fmt.Println(age1) // 报错，不可引用if中定义的变量
  }
  

• swtich

  • case后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）
  • case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
  • case后面可以带多个表达式，使用逗号间隔。比如case 表达式1,表达式2
  • case后面的表达式如果是常量（字面量），则要求不能重复
  • case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default
  • default 语句不是必须的
  • switch后也可以不带表达式，类似多个if-else分支来使用
  • switch后也可以直接声明/定义一个变量，分号结束，不推荐
  • switch穿透 fallthrough，如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透
  • Type switch：switch语句还可以用于 type-switch来判断某个interface变量中实际指向的变量类型

  package main
  
  import "fmt"
  
  func main() {
  	var x interface{}
  	var y = 10.0
  	x = y
  	switch i := x.(type) { // type switch 语法
  	case nil:
  		fmt.Printf("x 的类型：%T", i)
  	case int:
  		fmt.Printf("x 是 int 类型")
  	case float64:
  		fmt.Printf("x 是 float64 类型")
  	case func(int) float64:
  		fmt.Printf("x 是 func(int) float64 类型")
  	case bool, string:
  		fmt.Printf("x 是 bool 或 string 类型")
  	default:
  		fmt.Print("未知类型")
  	}
  }
  // x 是 float64 类型
  

  package main
  
  import "fmt"
  
  func test() string {
  	return "8"
  }
  
  func main() {
  	var a string = "8"
  
  	switch {
  		case a == "8":
  			fmt.Println("1")
  		case a == "9":
  			fmt.Println("2")
  	}
  
  	switch b := "3"; a {
  		case "1":
  			fmt.Println("1")
  		case "2", test():
  			fmt.Println("2")
  			fallthrough
  		case "3":
  			fmt.Println(b)
  		default:
  			fmt.Println("0")
  	}
  }
  
  // 输出 1   2   3
  

for range

传统for循环处理汉字时候会乱骂，需要进行切片处理（utf-8一个汉字对应3字节）

package main

import "fmt"

func main() {
	var str string = "123123北京"

	var str2 []rune = []rune(str)

	fmt.Printf("%T \n", str2)

	for i := 0; i < len(str2); i++ {
		fmt.Printf("index=%d,str2=%c \n", i, str2[i])
	}

	fmt.Println("=======================")

	for index, value := range str {
		fmt.Printf("index=%d,value=%c\n", index, value)
	}
}
/*
[]int32 
index=0,str2=1 
index=1,str2=2 
index=2,str2=3 
index=3,str2=1 
index=4,str2=2 
index=5,str2=3 
index=6,str2=北 
index=7,str2=京
*

break\continue标签的使用

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。

package main

import "fmt"

func main() {
	for i := 1; i <=3; i++ {
		fmt.Println("i=", i)
		label: // 定义当前for循环的标签
		for j := 1; j <= 2; j++ {
			if (j > 1) {
				break label // 跳出到该层标签
			}
			fmt.Println("j=", j)
		}
	}
}

continue 同理

package main

import "fmt"

func main() {
	label: // 定义当前for循环的标签
	for i := 1; i <=3; i++ {
		fmt.Println("i=", i)
		for j := 1; j <= 2; j++ {
			if (j > 1) {
				continue label // 直接继续下次循环
			}
			fmt.Println("j=", j)
		}
	}
}

包的注意事项和细节说明

1. 在给一个文件打包时，该包对应一个文件夹，文件的包名通常和文件所在的文件夹名一致，一般为小写字母
2. 当一个文件要使用其它包函数或变量时，需要先引入对应的包
3. package指令在文件第一行，然后import指令
4. 在import包时，路径从$GOPATH的src下开始，不用带src，编译器会自动从src下开始引入
5. 为了让其它包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其它语言的public，这样才能跨包访问
6. 在访问其它包函数时，其语法是包名.函数名
7. 如果包名较长，Go支持给包取别名，注意细节：取别名后，原来的包名就不能用了
8. 在同一包下，不能有相同的函数名，也不能有相同的全局变量名， 否则报重复定义
9. 如果你要编译成一个可执行程序文件，就需要将这个包声明为main，即package main 这个是一个语法规范。如果你是写一个库，包名可以自定义

函数的注意事项

1. 函数的形参列表可以是多个，返回值列表也可以是多个
2. 形参列表和返回值列表的数据类型可以是值类型和引用类型
3. 函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写该函数可以被本包文件和其它包文件使用，类似public，首字母小写，只能被本包文件使用，其它包文件不能使用，类似private
4. 函数中的变量是局部的，函数外不生效
5. 基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。
6. 如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。
7. go函数不支持重载。
8. 在go中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用
9. 函数既然是一种数据类型，因此在go中，函数可以 作为形参，并且调用

package main

import "fmt"

func num(n1 int, n2 int) int {
	return n1 + n2
}

func myNum(num func(int, int) int, n1 int, n2 int) int {
	return num(n1, n2)
}

func main() {
	n1 := 10
	n2 := 20
	funNum := num

	res := myNum(funNum, n1, n2)
	fmt.Println(res)
}
// 30

10. 为了简化数据类型的定义，go支持自定义数据类型
    1. 基本语法：type [自定义数据类型名] [数据类型]

package main

import "fmt"

func main() {
	type myInt int // 在go中，myInt 和 int 虽然都是 int 类型，但是 go 认为 myInt 和 int 是两个不同的类型
	var num myInt
	num = 10
	fmt.Printf("num,%T,%d", num, num)
}
// num,main.myInt,10

11. 支持对函数返回值命名

package main

import "fmt"

func num(n1 int, n2 int) (sum int, sub int) {
	sum = n1 + n2
	sub = n1 - n2
	return // 上面已经建立了对应关系，此处不需要指明返回值
}

func main() {
	sum, sub := num(20, 10)
	fmt.Println(sum) // 30
	fmt.Println(sub) // 10
}

12. 使用_标识符，忽略返回值
13. go支持可变参数。如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表最后。

package main

import "fmt"

func num(args... int) int {
	var sum int
	for _, value := range args {
		sum += value
	}
	return sum
}

func main() {
	res := num(10, 20, 30, 40, 10)
	fmt.Println(res) // 110
}

14. 当函数的形参类型一样时，可以在后面写类型，前面的形参数据类型可以省略。

package main

import "fmt"

func num(n1, n2 float32) float32 {
	return n1 + n2
}

func main() {
	res := num(1, 2)
	fmt.Println(res) // 3
}

init函数

每一个源文件都可以包含一个init函数，该函数会在main函数执行前，被go运行框架调用，也就是说init会在main函数前被调用。

全局变量的运行在init函数之前。

package main

import "fmt"

func init() {
	fmt.Println("init")
}

func main() {
	fmt.Println("main")
}
// init
// main

匿名函数

package main

import "fmt"

func main() {

	res := func (n1 int, n2 int) int {
		return n1 + n2
	}(10, 20)

	fmt.Println(res)

	mtFunc := func (n1 int, n2 int) int {
		return n1 + n2
	}
	res2 := mtFunc(1, 1)
	res3 := mtFunc(2, 1)

	fmt.Println(res2)
	fmt.Println(res3)
}
/*
30
2
3
*/

闭包

闭包就是一个函数和与其相关的引用环境组合的一个整体。

package main

import "fmt"

func add() func(int) int {
	var n int = 10 // 上下文n，受每次执行返回函数的影响
	return func (x int) int {
		n = n + x
		return n
	}
}

func main() {
	f := add()
	fmt.Println(f(1)) // 11
	fmt.Println(f(2)) // 13
	fmt.Println(f(3)) // 16
}

延时机制 defer

在函数中，程序员经常需要创建资源（比如：数据库连接、文件句柄、锁等），为了在函数执行完毕后，及时的释放资源，go的设计者提供defer（延时机制）

package main

import "fmt"

func sum(n1 int, n2 int) int {
	// 当执行到 defer 时候，暂时不执行，会将 defer 后面的语句"压入到独立的栈中"，然后继续执行函数下一个语句
	// 当函数执行完毕后，再从 defer 栈，按照先入后出的方式出栈执行
	// 在 defer 将语句放入到栈时，也会将相关的值拷贝同时入栈
	defer fmt.Println("n1=", n1) // n1 值不受下面修改影响，10
	defer fmt.Println("n2=", n2) // n2 值不受下面修改影响，20
	n1++
	n2++
	n3 := n1 + n2
	fmt.Println("n3=", n3)
	return n3
}

func main() {
	n1 := 10
	n2 := 20

	res := sum(n1, n2)
	fmt.Println("res=", res)
}

/*
n3= 32
n2= 20
n1= 10
res= 32
*/

字符串中常用的系统函数

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	var str string = "你好，世界"

	// 统计字符串长度
	strLen := len(str)
	fmt.Println(strLen) // 15

	// 字符串遍历
	runeStr := []rune(str)
	for index,value := range runeStr {
		fmt.Printf("index=%d,value=%c ", index, value)
	}
	// index=0,value=你 index=1,value=好 index=2,value=， index=3,value=世 index=4,value=界

	// 字符串转整数
	n,_ := strconv.Atoi("12")
	fmt.Println(n) // 12

	// 整数转字符串
	n1 := strconv.Itoa(12)
	fmt.Println(n1) // 12

	// 字符串转 []byte
	s1 := []byte(str)
	fmt.Println(s1) // [228 189 160 229 165 189 239 188 140 228 184 150 231 149 140]

	// []byte 转字符串
	s2 := string(s1)
	fmt.Println(s2) // 你好，世界

	// 十进制转二进制
	s3 := strconv.FormatInt(123, 2)
	fmt.Println(s3) // 1111011

	// 查找子串是否在指定的字符串中
	s4 := strings.Contains("hello word", "llo")
	fmt.Println(s4) // true

	// 统计一个字符串有几个指定的子串
	s5 := strings.Count("ceheese", "e")
	fmt.Println(s5) // 4

	// 不区分大小写的字符串比较
	s6 := strings.EqualFold("abc", "Abc")
	fmt.Println(s6) // true

	// 返回子串在字符串第一次出现的index值，如果没有返回-1
	s7 := strings.Index("asdfasdfasdf", "d")
	fmt.Println(s7) // 2

	// 返回子串在字符串最后一次出现的index，如果没有返回-1
	s8 := strings.LastIndex("asdfasdfasdf", "f")
	fmt.Println(s8) // 11

	// 将指定的子串替换成另外一个子串
	s9 := strings.Replace("hello world", "world", "bndong", -1)
	fmt.Println(s9) // hello bndong

	// 按照指定的某个字符为分割标识，将一个字符串拆分成字符串数组
	s10 := strings.Split("a,b,c,d,e", ",")
	fmt.Println(s10) // [a b c d e]

	// 按照指定的某个字符为拼接标识，将一个字符串数组拼接成字符串
	e1 := strings.Join(s10, "_")
	fmt.Println(e1) // a_b_c_d_e

	// 重复字符串
	e2 := strings.Repeat("aaa ", 3)
	fmt.Println(e2) // aaa aaa aaa

	// 将字符串的字母进行大小写转换
	s11 := strings.ToLower("BNDong")
	s12 := strings.ToUpper("BNDong")
	fmt.Println(s11) // bndong
	fmt.Println(s12) // BNDONG

	// 将字符串的左右两边的空格去掉
	s13 := strings.TrimSpace(" 123123 ")
	fmt.Println(s13) // 123123

	// 将字符串左右两边指定的字符去掉
	s14 := strings.Trim("！ 123123 ！", "！")
	fmt.Println(s14) //  123123

	// 将字符串左边指定的字符去掉
	s15 := strings.TrimLeft("！ 123123 ！", "！")
	fmt.Println(s15) //  123123 ！

	// 将字符串右边指定的字符去掉
	s16 := strings.TrimRight("！ 123123 ！", "！")
	fmt.Println(s16) // ！ 123123

	// 判断字符串是否以指定的字符串开头
	s17 := strings.HasPrefix("http://127.0.0.1", "http")
	fmt.Println(s17) // true

	// 判断字符串是否以指定的字符串结束
	s18 := strings.HasSuffix("http://127.0.0.1", "0.1")
	fmt.Println(s18) // true
}

时间日期函数

package main

import (
	"fmt"
	"time"
)

func main() {
	// 当前时间
	now := time.Now()

	// 当前时间信息
	fmt.Printf("年=%v\n", now.Year())
	fmt.Printf("月=%v\n", now.Month())
	fmt.Printf("月=%v\n", int(now.Month()))
	fmt.Printf("日=%v\n", now.Day())
	fmt.Printf("时=%v\n", now.Hour())
	fmt.Printf("分=%v\n", now.Minute())
	fmt.Printf("秒=%v\n", now.Second())

	// 把时间格式化成字符串
	fmt.Println(time.Now().Format("2006-01-02 15:04:05")) // 2006-01-02 15:04:05 中时间数字是固定的，不能修改

	// 把日期字符串转化为时间
	fmt.Println(time.Parse("01-02-2006", "06-17-2013"))

	// 获取当前时间纳秒时间戳
	fmt.Println(time.Now().UnixNano())

	// 延时1000毫秒执行
	time.Sleep(time.Millisecond * 1000)
	fmt.Println("ok")
}

/*
年=2022
月=January
月=1
日=5
时=14
分=15
秒=31
2022-01-05 14:15:31
2013-06-17 00:00:00 +0000 UTC <nil>
1641363331933338000
ok
*/

错误处理

1. go语言追求简洁优雅，所以，go语言不支持传统的try...cath...finally这处处理
2. go中引入的处理方式为：defer，panic，recover
3. 这几个异常的使用场景可以这么简单描述：go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理

package main

import "fmt"

func main() {
	// 使用 defer + recover 来捕获和处理异常
	defer func(){
		err := recover()
		if err != nil {
			fmt.Println(err)
		}
	}()
	n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println(res)
}

自定义错误

go 程序中，也支持自定义错误，使用errors.New 和 panic 内置函数

1. errors.New("错误说明")，会返回一个error类型的值，表示一个错误
2. panic内置函数，接收一个interface{}类型的值作为参数。可以接收error类型的变量，输出错误信息，并退出程序

package main

import (
	"errors"
	"fmt"
)

// 函数去读取以配置文件的信息
// 如果文件名传入不正确，我们就返回一个自定义错误
func readConf(name string) (err error) {
	if name == "config.ini" {
		// 读取...
		return nil
	}
	// 返回一个自定义错误
	return errors.New("读取文件错误...")
}

func main() {
	err := readConf("config.ini")
	if err != nil {
		// 如果读取文件错误，就输出这个错误，并终止程序
		/*
		内建函数panic停止当前Go程的正常执行。当函数F调用panic时，F的正常执行就会立刻停止。
		F中defer的所有函数先入后出执行后，F返回给其调用者G。G如同F一样行动，层层返回，直到该Go程中所有函数都按相反的顺序停止执行。
		之后，程序被终止，而错误情况会被报告，包括引发该恐慌的实参值，此终止序列称为恐慌过程。
		 */
		panic(err)
	}

	fmt.Println("test")
}

/*
错误情况输出：
panic: 读取文件错误...

goroutine 1 [running]:
main.main()
*/

数组

1. 数组是多个相同数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化
2. var arr []int 这时 arr 就是一个slice切片
3. 数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用
4. 数组创建后，如果没有赋值，有默认值
   1. 数值类型数组：默认值为0
   2. 字符串数组：默认值为“”
   3. bool数组：默认值为false
5. 数组的下标是从0开始的
6. 数组下标必须在指定范围内使用，否则报 panic：数组越界
7. go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝
8. 如想在其它函数中，去修改原来的数组，可以使用引用传递（指针方式）

package main

import "fmt"

func main() {
	// 定义一个数组
	var hens [6]int

	// 给数组每个元素赋值
	hens[0] = 10
	hens[1] = 20
	hens[2] = 30
	hens[3] = 40
	hens[4] = 50
	hens[5] = 60

	// 数组遍历
	for index,value := range hens {
		fmt.Printf("index=%d,value=%d,&value=%p\n", index, value, &hens[index])
	}

	// 定义数组的其它方式
	var arr1 [3]int = [3]int {1,2,3}
	var arr2 = [3]int {1,2,3}
	var arr3 = [...]int {6,7,8}
	var arr4 = [3]string {1:"tom", 2:"jack", 0:"marry"}
	var arr5 = [...][2]int{
		{1, 2},
		{4, 5},
	}
	var arr6 [3][2]string = [...][2]string{
		{"a", "b"},
		{"c", "d"},
		{"f", "g"},
	}

	fmt.Println(arr1)
	fmt.Println(arr2)
	fmt.Println(arr3)
	fmt.Println(arr4)
	fmt.Println(arr5)
	fmt.Println(arr6)
}
/*
index=0,value=10,&value=0xc0000200c0
index=1,value=20,&value=0xc0000200c8
index=2,value=30,&value=0xc0000200d0
index=3,value=40,&value=0xc0000200d8
index=4,value=50,&value=0xc0000200e0
index=5,value=60,&value=0xc0000200e8
[1 2 3]
[1 2 3]
[6 7 8]
[marry tom jack]
[[1 2] [4 5]]
[[a b] [c d] [f g]]
*/

切片

1. 切片的英文是slice
2. 切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制
3. 切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样
4. 切片的长度是可以变化的，因此切片是一个动态变化数组
5. 切片定义的基本语法：var 变量名 []类型
6. 切片初始化时 var slice = arr[startIndex:endIndex]：从arr数组下标为startIndex，取到下标为endIndex的元素（不含arr[endIndex]）
7. 切片初始化时，仍然不能越界，范围在[0~len(arr)]之间，但是可以动态增长
   1. var slice = arr[0:end] 可以简写 var slice = arr[:end]
   2. var slice = arr[start:len(arr)] 可以简写 var slice = arr[:end]
   3. var slice = arr[0:len(arr)] 可以简写 var slice = arr[:]
8. cap 是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素
9. 切片定义完成后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用
10. 切片可以继续切片
11. 用append内置函数，可以对切片进行动态追加
    1. 切片append操作的本质就是对数组扩容
    2. go底层会创建一下新的数组newArr(安装扩容后大小)
    3. 将slice原来包含的元素拷贝到新的数组newArr
    4. slice重新引用到newARR
    5. 注意newArr是在底层维护的，程序员不可见

package main

import "fmt"

func main() {
	// 演示切片的基本使用
	intArr := [...]int{1,22,33,44,55} // 定义一个数组

	fmt.Printf("intArr,%T,%v\n", intArr, intArr) // intArr,[5]int,[1 22 33 44 55]

	// 声明/定义一个切片
	// 1. slice 就是切片名
	// 2. intArr[1:3] 表示 slice 引用到 intArr 这个数组
	// 3. 引用 intArr 数组的起始下标为1，最后的下标为3（但是不包括3）
	slice := intArr[1:3]
	fmt.Printf("slice,%T,%v\n", slice, slice) // slice,[]int,[22 33]
	fmt.Println("slice len,", len(slice)) // 元素个数：2
	fmt.Println("slice cap,", cap(slice)) // 容量：4 （切片的容量是可以动态变化的）

	// 0 -- 22
	// 1 -- 33
	for index,value := range slice {
		fmt.Println(index, "--", value)
	}

	// slice 切片是引用，内存地址一致
	fmt.Println(&(slice[0])) // 0xc0000200c8
	fmt.Println(&(intArr[1])) // 0xc0000200c8
	slice[0] = 88
	fmt.Println(slice) // [88 33]
	fmt.Println(intArr) // [1 88 33 44 55]

	// 通过make来创建切片
	/**
	通过 make 和 intArr[1:3] 创建切片的区别
	1. intArr[1:3] 是直接引用数组，这个数组是事先存在的，程序员是可见的
	2. make 来创建切片，make 也会创建一个数组，是由切片在底层进行维护，程序员是看不见的
	 */
	var arr []int = make([]int, 4, 8)
	arr[0] = 1
	arr[1] = 2
	arr[2] = 3
	arr[3] = 4
	fmt.Println(arr) // [1 2 3 4]

	// 定义一个切片，直接就指定具体数组，使用原理类似make的方式
	var strSlice []string = []string{"tom", "jack", "mary"}
	fmt.Println(strSlice) // [tom jack mary]
	fmt.Println(len(strSlice)) // 3
	fmt.Println(cap(strSlice)) // 3

	// 切片扩容
	slice2 := []int{100,200,300,400}
	// []int,[100 200 300 400],0xc00001a080
	fmt.Printf("%T,%v,%p\n", slice2, slice2, slice2)

	slice3 := append(slice2, 500, 600)
	// []int,[100 200 300 400],0xc00001a080
	fmt.Printf("%T,%v,%p\n", slice2, slice2, slice2)
	// []int,[100 200 300 400 500 600],0xc00001e1c0
	fmt.Printf("%T,%v,%p\n", slice3, slice3, slice3)

	slice4 := append(slice3, slice2...)
	// []int,[100 200 300 400 500 600 100 200 300 400],0xc0000c2000
	fmt.Printf("%T,%v,%p\n", slice4, slice4, slice4)

	// 切片拷贝
	slice5 := []int{1,2,3,4,5}
	// []int,[1 2 3 4 5],0xc0000b40c0
	fmt.Printf("%T,%v,%p\n", slice5, slice5, slice5)
	slice6 := make([]int, 10)
	// []int,[0 0 0 0 0 0 0 0 0 0],0xc0000c4000
	fmt.Printf("%T,%v,%p\n", slice6, slice6, slice6)
	copy(slice6, slice5)
	// []int,[1 2 3 4 5 0 0 0 0 0],0xc0000c4000
	fmt.Printf("%T,%v,%p\n", slice6, slice6, slice6)

}

string 和 slice

package main

import "fmt"

func main() {
	str := "hello.world"

	// string底层是一个byte数组，因此string也可以进行切片处理
	slice := str[6:]
	fmt.Println(slice) // world

	// string是不可变的，也就是说不能直接通过str[0]='z' 方式来修改字符串
	// 如果需要修改字符串可以先将string -> []rune -> 修改 -> 重新转成string
	strByte := []rune(str)
	fmt.Println(strByte) // [104 101 108 108 111 46 119 111 114 108 100]
	strByte[0]  = 'z'
	str2 := string(strByte)
	fmt.Println(str2) // zello.world

}

map

1. 基本语法：var map变量名 map[keytype]valuetype
   1. var a map[string]string
   2. var a map[string]int
   3. var a map[int]string
   4. var a map[string]map[string]string
2. 声明是不会分配内存的，初始化需要make，分配内存后才能赋值和使用
3. map的curd操作

package main

import "fmt"

func main() {
	var map1 map[int]string
	map1 = make(map[int]string, 2)

	map1[2] = "1"
	map1[5] = "2"
	map1[3] = "3"
	map1[1] = "4"

	// 新版本的map的key会进行排序，老版本里面的值是随机的
	fmt.Println(map1) // map[1:4 2:1 3:3 5:2]

	// 增加
	map1[6] = "5"
	fmt.Println(map1) // map[1:4 2:1 3:3 5:2 6:5]

	// 修改
	map1[6] = "6"
	fmt.Println(map1) // map[1:4 2:1 3:3 5:2 6:6]

	// 查询
	val, findRes := map1[3]
	fmt.Println(val)
	fmt.Println(findRes) // 如果存在findRes为true否则为false

	// 删除
	delete(map1, 6)
	fmt.Println(map1) // map[1:4 2:1 3:3 5:2]
}

4. map是引用类型，遵守引用类型传递的机制，在一个函数接收map，修改后，会直接修改原来的map
5. map的容量达到后，再想map增加元素，会自动扩容，并不会发生panic，也就是说map能动态的增长键值对
6. map的value也经常使用struct类型，更适合管理复杂的数据

struct 结构体

1. 结构体定义：type 结构体名称 struct {}

package main

import "fmt"

type Stu struct{
	Name string
	Age int
	Func func(int, int) int
}

func main() {

	// 定义结构体方式1
	var s1 Stu
	s1.Name = "dbnuo"
	s1.Age = 20
	s1.Func = func(a int, b int) int {
		return a + b
	}

	fmt.Println(s1) //{dbnuo 20 0x108ba60}
	fmt.Println(s1.Func(1, 2)) // 3
	fmt.Printf("%T", s1.Func) // func(int, int) int

	// 定义结构体方式2
	s2 := Stu{"dbnuo", 21, func(a int, b int) int {
		return a + b + 10
	}}
	fmt.Println(s2) // func(int, int) int{dbnuo 21 0x108bb60}
	fmt.Println(s2.Func(1, 2)) // 13

	// 定义结构体方式3
	var s3 *Stu = new(Stu)
	s3.Name = "aaa"
	fmt.Println(*s3) // {aaa 0 <nil>}

	// 定义结构体方式4
	s4 := Stu{
		Name: "dbnuo",
		Age: 21, // 最后都要有逗号
	}
	fmt.Println(s4) // {dbnuo 21 <nil>}
}

2. 结构体的所有字段在内存中是连续的

3. 结构体是用户单独定义的类型，和其它类型进行转换时需要有完全相同的字段

package main

import "fmt"

type A struct {
	Num int
}

type B struct {
	Num int
}

func main() {
	var a A
	var b B
	a = A(b) // 可以进行转换，两个结构体内部完全一致
	fmt.Println(a, b) // {0} {0}
}

4. 结构体进行type重新定义（相当于取别名）。go认为是新的数据类型，但是相互间可以强转

package main

import "fmt"

type Student struct {
	Name string
}

type Stu Student

func main() {
	var stu1 Student
	var stu2 Stu

	// stu2 = stu1 // 不能直接赋值，数据类型不同
	stu2 = Stu(stu1) // 可以相互间进行转换

	fmt.Println(stu1, stu2)
}

5. struct的每个字段上，可以写上一个tag，该tag可以通过反射机制获取，常见的使用场景就是序列化和反序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Name string `json:"name"` // json:"name" 为 tag 标签
	Age int `json:"age"`
}

func main() {
	var stu Student

	stu.Name = "dbnuo"
	stu.Age  = 10

	stuJson, err := json.Marshal(stu)

	fmt.Println(string(stuJson)) // {"name":"dbnuo","age":10}
	fmt.Println(err)
}

方法

1. 方法的声明

   func (recevier type) methodName (参数列表) （返回值列表）{
     方法体
     return 返回值
   }
   

   1. 参数列表：表示方法输入
   2. recevier type：表示这个方法和type这个类型进行绑定，或者说该方法作用于type类型
   3. receiver type：type可以是结构体，也可以其它的自定义类型
   4. receiver：就是type类型的一个变量(实例)
   5. 返回值列表：表示返回的值，可以多个
   6. 方法主体：表示为了实现某一功能代码块
   7. return语句不是必须的

2. go中的方法是作用在指定的数据类型上的（即：和指定的数据类型绑定），因此自定义类型，都可以有方法，而不仅仅是struct

3. 结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式

4. 如希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理

package main

import "fmt"

type Student struct {
	Name string
}

/**
方法定义：值传递
 */
func (s Student) test() {
	s.Name = "bndong"
	fmt.Println(s.Name) // bndong
}
  
/**
方法定义：引用传递
 */
func (s *Student) test1() {
	s.Name = "bndong"
	fmt.Println(s.Name) // bndong
}

func main() {
	var s Student
	s.Name = "dbnuo"
	s.test()
	fmt.Println(s.Name) // 值拷贝，方法里不对外部变量影响，所以还是输出 dbnuo
	s.test1()
	fmt.Println(s.Name) // 因为是引用传递，方法里外部变量影响，所以输出 bndong
} 

5. 方法的访问范围控制的规则和函数一样。方法名首字母小写，只能在本包访问，方法名首字母大写，可以在本包和其它包访问
6. 如果一个变量实现了String()这个方法，那么fmt.Println默认会调用这个变量的String()进行输出

方法和函数的区别

1. 调用方式不一样
   1. 函数的调用方式：函数名(实参列表)
   2. 方法的调用方式：变量.方法名(实参列表)
2. 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然
3. 对于方法，接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样可以

package main

import "fmt"

type Student struct {
	Name string
}

// 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然
func test1(s Student)  {
	fmt.Println(s.Name)
}

func test2(s *Student)  {
	fmt.Println(s.Name)
}

// 对于方法，接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以
func (s Student) test3()  {
	s.Name = "bndong"
	fmt.Println(s.Name)
}

func main() {
	var s Student
	s.Name = "dbnuo" 

	test1(s)
	test2(&s)

	s.test3()
	fmt.Println(s.Name)
	(&s).test3() // 从形式上是传入地址，但是本质上仍然是值拷贝
	fmt.Println(s.Name)
}

面向对象：继承

在go中，如果一个struct嵌套了另外一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性

1. 结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母大写或者小写的字段、方法，都可以使用
2. 匿名结构体字段访问可以简化
3. 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分
4. 结构体嵌入两个（或多个）匿名结构体，如两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段和方法），在访问时，就必须明确指定匿名结构体名字，否则编译报错
5. 嵌套匿名结构体后，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值

package main

import "fmt"

type Stu struct{
	Name string
	Age int
}

func (s *Stu) stuHello() {
	fmt.Println("stu hello", s.Name)
}

type Stu1 struct {
	Name string
	Age  int
	stu1 int
	sp float64
}

type Pupil struct {
	Stu
	asStu Stu1 // 有名结构体，下面的字段和方法必须通过名字访问，不能简化
	Score int
	sp float64
}

func main() {
	p := Pupil{}
	// p.Name = "a" // 当字段在两个匿名结构体中都存在时候，同时结构体本身没有同名的字段或方法，不能直接简化使用，会报错：ambiguous selector p.Name
	p.asStu.Name = "a"
	p.Stu.Age = 10
	p.Score = 60
	p.asStu.stu1 = 70 // 有名结构体里的字段，必须通过名字访问，不能简化
	p.sp = 12.32 // 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问

	/**
	注意：stuHello方法在Stu的匿名结构体中，但是程序中并没有给Stu结构体中Name赋值
	所以stuHello方法运行时候读取不到Name的值，结果输出：stu hello
	如果赋值了其它匿名结构体中同名字段，对其它拥有同名字段的匿名结构体不会产生影响，数据空间具有独立性
	*/
	p.stuHello() // 输出：stu hello
	fmt.Println(p) //{{ 10} {a 0 70 0} 60 12.32}

	// 直接指定各个匿名结构体字段的值
	p1 := Pupil{
		Stu: Stu{
			Name: "dbnuo",
			Age: 12,
		},
		asStu: Stu1{
			Name: "aaaa",
			Age: 13,
			stu1: 14,
			sp: 11.11,
		},
		Score: 12,
		sp: 12.11,
	}

	fmt.Println(p1) // {{dbnuo 12} {aaaa 13 14 11.11} 12 12.11}
}

类型断言

package main

import "fmt"

type Stu struct {
	x int
	y int
}

func main() {
	var a interface{}
	var s = Stu{1, 2}
	a = s

	var b Stu

	b ,res := a.(Stu) // 类型断言，表示判断a是否指向Stu类型的变量，如果是就转成Stu类型的变量，如果是就转成Stu类型并赋值给b变量，否则报错

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(res)
}

文件读取和写入

package main

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"os"
)

func main() {
	filePath := "/Users/dbnuo/Development/Docker/dnmp/www/golang/test/src/go_code/project/main/test"

	// 打开文件
	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, os.ModePerm)
	if err != nil {
		fmt.Println("打开文件失败")
		fmt.Println(err)
	} else {
		fmt.Println("打开文件成功")

		// 使用延时机制关闭文件
		defer func(file *os.File) {
			var err = file.Close()
			if err != nil {
				fmt.Println("关闭文件失败")
				fmt.Println(err)
			} else {
				fmt.Println("关闭文件成功")
			}
		}(file)
	}

	// 判断文件是否存在
	_, err = os.Stat(filePath)
	switch {
	case err == nil:
		fmt.Println("文件存在")
	case os.IsNotExist(err):
		fmt.Println("文件不存在")
	default:
		fmt.Println("未知错误")

	}

	// 读取文件
	b := make([]byte, 10)
	num, err := file.Read(b)
	if err != nil {
		fmt.Println("读取文件失败")
		fmt.Println(err)
	} else {
		fmt.Println("读取文件字节数：", num)
		fmt.Println("读取文件成功：", string(b))
	}

	// 一次性读取文件（不适合大文件）
	file.Seek(0, 0) // 将指针置于文件开始
	str, err := ioutil.ReadFile(filePath)
	if err != nil {
		fmt.Println("一次性读取文件失败")
		fmt.Println(err)
	} else {
		fmt.Println("一次性读取文件成功：")
		fmt.Printf("%v\n", string(str))
	}

	// 缓冲读取内容
	file.Seek(0, 0) // 将指针置于文件开始
	reader := bufio.NewReader(file)
	fmt.Println("缓冲读取文件：")
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF {
			fmt.Printf("%v",str)
			break
		}
		fmt.Printf("%v", str)
	}
	fmt.Println()

	// 写入文件内容
	_, err = file.WriteString("\nhahahaha")
	if err != nil {
		fmt.Println("写入文件失败")
		fmt.Println(err)
	} else {
		fmt.Println("写入文件成功")
	}

	// 带缓存写入文件内容
	writer := bufio.NewWriter(file)
	_, err = writer.WriteString("\nlalalala")
	if err != nil {
		fmt.Println("带缓存写入文件失败")
		fmt.Println(err)
	} else {
		fmt.Println("带缓存写入文件成功")
		// 因为writer是带缓存的，因此在调用WriteString方法时，其实内容是先写入到缓存中的，
		// 所以需要调用Flush方法，将缓存的数据真正写入到文件中，否则文件会丢失数据
		writer.Flush()
	}
}

序列化和反序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Stu struct {
	Name string
	Age int
}

func main() {

	// 结构体 json 序列化
	stu := Stu{
		Name: "bndong",
		Age: 22,
	}
	data, err := json.Marshal(stu)
	fmt.Println(string(data))
	fmt.Println(err)

	// map json 序列化
	var a map[string]interface{}
	a = make(map[string]interface{}, 2)
	a["name"] = "张三"
	a["age"]  = 12
	a["arr"]  = []int{1,2,3,4}
	data1, err1 := json.Marshal(a)
	fmt.Println(string(data1))
	fmt.Println(err1)

	var jsonData interface{}
	// 反序列化
	json.Unmarshal(data, &jsonData)
	fmt.Printf("%T,%v\n", jsonData, jsonData) // map[string]interface {},map[Age:22 Name:bndong]

	json.Unmarshal(data1, &jsonData)
	fmt.Printf("%T,%v\n", jsonData, jsonData) // map[string]interface {},map[age:12 arr:[1 2 3 4] name:张三]

}

单元测试

1. 测试用例文件名必须以 _test.go 结尾
2. 测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名
3. 一个测试用例文件中，可以有多个测试用例函数
4. 运行测试用例指令：
   1. go test 如果运行正确，无日志，错误时，会输出日志
   2. go test -v 运行正确或是错误，都输出日志
5. 当出现错误时，可以使用 r.Fatalf 来格式化输出错误信息，并退出程序
6. t.Logf 方法可以输出相应的日志
7. 测试用例函数，并没有放在main函数中，也执行了，这就是测试用例的方便之处
8. PASS 表示测试用例运行成功，FAIL 表示测试用例运行失败
9. 测试单个文件，一定要带上被测试的原文件：go test -v cal_test.go cal.go
10. 测试单个方法：go test -v -test.run TestAddUpper

package main

import "testing"

func TestNum(t *testing.T)  {
	res := num(10)
	if res != 91 {
		t.Fatalf("执行测试错误，期望91，实际输出%v", res)
	}
	t.Logf("执行成功")
}

goroutine

• 进程和线程说明
  • 进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位
  • 线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位
  • 一个进程可以创建和销毁多个线程，同一个进程中的多个线程可以并发执行
  • 一个程序至少有一个进程，一个进程至少有一个线程
• 并发和并行
  • 多线程程序在单核上运行，就是并发
    • 因为是一个cpu上，比如有10个线程，每个线程执行10毫秒（进行轮询操作），从人的角度看，好像这10个线程都在运行，但是从微观上看，在某一个时间点看，其实只有一个线程在执行，这就是并发
  • 多线程程序在多核上运行，就是并行
    • 因为是在多个cpu上（比如有10个cpu），比如有10个线程，每个线程执行10毫秒（各自在不同cpu上执行），从人的角度看，这10个线程都在运行，但是从微观上看，在某一个时间点看，也同时有10个线程在执行，这就是并行
• go协程和go主线程
  • go主线程（也可以理解成进程）：一个go线程上，可以起多个协程。协程是轻量级的线程
• go协程的特点
  • 有独立的栈空间
  • 共享程序堆空间
  • 调度由用户控制
  • 协程是轻量级的线程