1、Go核心编程（基础部分）

Go入门介绍

Golang特点

Go语言既能达到静态语言的安全和性能，又达到了动态语言开发维护的高效，使用一个表达式来形容Go语音（Go = C + Python），说明Go语言既有C静态语言程序的运行速度，又能达到Python动态语言的快速开发。
1、go从C语言中继承了很多理念，包括表达式语法、控制结构、基础数据类型、调用参数传值、指针（弱化指针）等，也保留了和C语言一样的编译执行方式。
2、函数可以返回多个值
3、引入包的概念，用于组织程序结构，Go语言的一个文件都要归属于一个包，而不能单独存在。
4、垃圾回收机制，内存自动回收，不需要开发人员管理。
5、天然并发

• 从语言层面支持并发，实现简单
• goroutine，轻量级线程，可实现大并发处理，高效利用多核
• 基于CPS并发模型实现

6、吸收了管道通信机制，形成Go语言特有的channel，通过管道channel，可以实现不同的goroute之间的相互通信
7、新的创新，比如切片slice，延时执行defer等

Golang操作（入门级）

1、GO程序执行
		go build go1.go --> go1.exe通过go build生成可执行文件.exe，然后执行可执行文件即可
		go run go1.go 通过go run 直接执行，需要电脑有go的环境，不会生成其他文件
2、Go语法要求
		每条语句不需要分号结尾，因此，一行也只能有一条语句
		导入的包或者是定义的变量如果没有使用到会报错，无法通过编译( 如果没有使用fmt中的函数--> imported and not used: "fmt")
		缩进是一次tab键，没有缩进不会出现语法错误，仅是格式不对
		注释和c语言一样
		函数左侧花括号不能独立一行，否则会报错。只能是和函数名同一行，然后换行写语句。
			# command-line-arguments
			.\go1.go:19:1: syntax error: unexpected semicolon or newline before {
   
3、格式化代码
		gofmt go1.go 可以将该文件中的代码格式化之后输出到控制台
		gofmt -w go1.to 可以将文件中的代码格式化之后写入到文件中

Golang变量

1、变量使用步骤

变量使用步骤
		声明变量（定义变量）
			基本语法：var 变量名 数据类型
			比如，var a int声明一个int类型的变量a
			
		初始化变量
			在声明变量的时候就赋值
			var a int = 90 这就是初始化变量a。
			细节：如果声明的时候就直接赋值，可以省略数据类型（自动推导类型）
				var b = 99
				
		变量赋值
			如果只是声明了变量：var num int //默认值为0
			然后再给值num = 99这就是赋值。

2、局部变量的使用方式

第一种：指定变量类型，声明后若不赋值，使用默认值

package main
import "fmt"

func main() {
   
	//这种方式相当于直接使用定义了一个变量，使用他的默认值
	var i int
	fmt.Println("i = ", i)

	var f float64
	fmt.Println("f = ", f)

	var s string
	fmt.Println("s = ", s, "s ==\"\" ?", s == "")
}

第二种：根据值自行判定变量类型(类型推导)
这种方式下必须在定义的时候赋值，不能后期赋值。这种方式也不存在默认值一说，因为一开始就要手动赋值，否则会报错。

package main
import "fmt"

func main() {
   

	var i = 98
	fmt.Println("i = ", i)

	var s = "你好"
	fmt.Println("s = ", s)

}

错误情况

第三种：省略 var, 注意 :=左侧的变量不能是已经声明过的，否则会导致编译错误。
这种方式既然省略了var关键字，就不能再使用它，否则会报错。

package main
import "fmt"

func main() {
   

	//相当于 var name string 	name= "kiko"
	name := "kiko"
	fmt.Println("name: ", name)

}

总结三种变量的使用方式。
基于基本语法 var + 变量名 + 数据类型的语法格式，第一种是标准的格式；第二种则是省略数据类型，因为这个变量可以在声明的时候赋初值（自动类型推导），当然此处不省略数据类型也可以，但是必须赋初值；第三种则是在var上做文章，var也可以省略，但是必须要使用:=的形式，且要赋初值，这里的var就必须要省略。
综上，除了第一种标准的格式，其他两种都是在var和数据类型上面做省略，且两者的共同点就是必须要赋初值。

一次性声明多个变量
声明多个变量的从上面三种方式引申而出。

package main
import "fmt"

func main() {
   

	//多变量声明方式1（基本形式，只能是一种类型）
	var n1, n2, n3 int	
	n1 = 99
	fmt.Println("n1 = ", n1, "n2 = ", n2, "n3 = ", n3)	//n1 =  99 n2 =  0 n3 =  0

	//多变量声明方式2(省略数据类型)
	var n4, psw, distance = 190, "admin", 99.99
	fmt.Println("n4 =", n4, "psw =", psw, "distance =", distance) //n4 = 190 psw = admin distance = 99.99

	//多变量声明方式3(省略var)
	n5, n6, n7 := 999, 99.99, "vovo"
	fmt.Println("n5 =", n5, "n6 =", n6, "vovo =", n7)
}

3、全局变量的使用方式

全局变量和局部变量的使用方式基本相同，前两种方式是一样的，但是全局变量没有 := 定义的方式，此外全局变量可以定义在一起，共用一个var关键字。
全局变量在使用过程中通常都是设置了一个初始值，一般不会只声明全局变量。

package main
import "fmt"

func main() {
   

	//输出全局变量
	fmt.Println("gn1 = ", gn1, "gn2 =", gn2, "gn3 =", gn3, "gn4 =", gn4, "gn5 =", gn5, "gn6 =", gn6)
	
}

/*
	全局变量可以定义在使用了全局变量函数的后面
*/

//定义全局变量
var gn1 = 100
var gn2 = 888.888
var gn3 = "yoyo"

//上面的声明方式可以改成一次性声明
var (
	gn4 = 500
	gn5 = 999.999
	gn6 = "kiko"
)

4、变量使用的注意事项

• 变量 = 变量名 + 数据类型 + 数值缺一不可。
• Golang的变量如果没有赋初值，编译器会使用默认值，比如 int 默认值 0 ，string 默认值为空串，即""，小数默认为 0。
• 变量在同一个作用域(在一个函数或者在代码块)内不能重名。

5、程序中的+号

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

package main
import "fmt"

func main() {
   

	//数值类型的 + 
	var i = 10
	// var f = 19.9	//这里测试要注释掉，因为没有使用到f这个变量，否则编译出错
	var i1 = 20
	//两种不同的数值类型不能做 加法运算，这里的i + f是无法通过编译的
	var res1 = i + i1
	fmt.Println(" i + f = ", res1,)

	//字符串
	name := "kiko"
	friend := "yoyo"
	res2 := name + friend
	fmt.Println("name + friend = ", res2)

}

Golang数据类型（基本类型）

1、数据类型分类

2、整型

第一种、有符号整数

第二种、无符号整数

第三种、其他整数类型

使用对应的类型，数值就不能超过类型限定的值，否则无法编译通过。

整型的使用细节

• Golang 各整数类型分：有符号和无符号，int uint 的大小和系统有关。
• Golang 的整型默认声明为 int 型，就是自动推导的类型。
  
• 查看变量类型和所占子节大小
  
• Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如：年龄，使用byte类型就足够了】
• bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。

3、小数类型/浮点型

1. 类型分类（都是有符号的）
   

package main
import (
	"fmt"
	"unsafe"
)

func main(){
   
	
	var f float32 = 10.2000001
	fmt.Println("f = ", f)
	fmt.Printf("type = %T, size = %d\n", f, unsafe.Sizeof(f))

	var d = 123.898323212	//默认自动推导到float64
	fmt.Println("d = ", d)
	fmt.Printf("type = %T, size = %d\n", d, unsafe.Sizeof(d))
}

2. 类型说明
   关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位。
   尾数部分可能丢失，造成精度损失。
   浮点型的存储分为三部分：符号位+指数位+尾数位 在存储过程中，精度会有丢失。

3. 使用细节

Golang 浮点类型有固定的范围和字段长度，不受具体OS(操作系统)的影响。
Golang 的浮点型默认声明为 float64 类型。
浮点型常量有两种表示形式：
	十进制数形式：如：5.12 .512 (必须有小数点）
	科学计数法形式:如：5.1234e2 = 5.1234 * 10 的 2 次方 5.12E-2 = 5.12/10 的 负2次方
通常情况下，应该使用 float64 ，因为它比 float32 更精确。[开发中，推荐使用 float64]

package main
import (
	"fmt"
	"unsafe"
)

func main() {
   

	//十进制形式：如 5.12   .512（必须有小数点）
	num1 := 5.12
	num2 := .512
	fmt.Println("num1: ", num1, " num2: ", num2)
	fmt.Printf("num1 type %T: num1 size %d\n", num1, unsafe.Sizeof(num1))

	//科学计数法形式
	num3 := 5.1234e2
	num4 := 5.1234E2
	num5 := 5.1234E-2
	fmt.Println("num3: ", num3, " num4: ", num4, " num5: ", num5)
	fmt.Printf("num3 type %T: num3 size %d\n", num3, unsafe.Sizeof(num3))

}

4、字符类型

***基本介绍
go语言中没有专门的类型用来存储字符。如果要存储单个字符(字母)，一般使用 byte 来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。

package main
import(
	"fmt"
)

func main()