一、基本介绍
1、开发环境安装-windows安装
打开Golang官网，选择对应版本，进行安装。
2、环境变量配置
1）步骤
（1）首先在环境变量中添加 GOPATH，值为 go 的安装目录：
（2）然后在环境变量 PATH 中添加 go 安装目录下的 bin 文件夹。
（3）接着添加一个环境变量 GOPATH，值为你自己希望的工作目录。
（4）最后重启一下 命令行工具，输入 go version命令即可查看版本信息
2）GOROOT
$GOROOT,便是 Go 的安装路径，存放 Go 的内置程序库。通常你安装完后，你电脑的环境变量就会设好 GOROOT 路径。当你开发 Go 程序的时候，当你 import 内置程序库的时候，并不需要额外安装，而当程序运行后， 默认也会先去 GOROOT 路径下寻找相对应的库来运行。
3）GOPATH与Go工作区
GOPATH 是我们定义的自己的工作空间。
一个 GOPATH 工作区，一般这样：
./
├── bin
├── pkg
└── src
├── hello_github
└── hello_router.go
（1）bin：保存编译后生成的可执行文件。我们的操作系统使用$PATH环境变量来查找无需完整路径即可执行的二进制应用程序，建议将此目录:$GOPATH/bin添加到我们的全局 $PATH 变量中。
（2）pkg：它保存已安装的包对象（比如：.a）。每个目标操作系统和体系结构对都有自己的 pkg 子目录。 Go 编译包时生成的中间文件，用来缓存提高编译效率。
（3）src：包含源代码(比如：.go .c .h .s等)。 该路径决定 import 包时的导入路径或可执行文件名称。
import包的搜索顺序：
GOROOT/src：该目录保存了Go标准库代码。
GOPATH/src：该目录保存了应用自身的代码和第三方依赖的代码。
3、Go程序开发注意事项
1）Go源文件以“go”为扩展名
2）Go应用程序的执行入口是main()方法
3）Go语言严格区分大小写
4）Go方法由一条条语句构成，每个语句后不需要分号（Go语言会在每行后自动加分号）
5）Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多余语句写在同一行，否则会报错。
6）Go语言定义的变量或者import的包如果没有使用到，代码不能编译通过。
7）大括号都是成对出现的，缺一不可。
4、常用的转义字符（escape char）
5、Go变量
1）使用基本步骤
（1）声明变量（定义变量）
（2）赋值
（3）使用
2）Golang变量声明和赋值的三种方式
（1）指定变量类型，声明后若不赋值，使用默认值
//声明同时赋值 var 变量名字 类型 = 表达式 //声明时不赋值 var 变量名字 类型
（2）根据值自行判定变量类型（类型推导）
var 变量名字 = 表达式
（3）省略var，注意:=左侧的变量不应该是一级声明过的，否则会导致编译错误
变量名字 := 表达式
3）多变量声明
//可以声明时赋值，也可以不赋值 var 变量名字1,变量名字2 类型 ////声明时需赋值 var 变量名字1,变量名字2 =值1,值2 //类型推导，需要赋值 变量名字1,变量名字2 :=值1,值2
6、数据类型
1）基本数据类型：变量存的就是值，也叫值类型。
（1）数值型
整数类型、浮点类型
（2）字符型
使用byte来保存单个字符字符
（3）布尔型（bool）
（4）字符串（string）:官方将string归属到基本数据类型
2）派生数据类型
（1）指针（Pointer）-引用类型
指针类型：变量存的是一个地址，这个地址指向的空间存的才是值。获取指针类型所指向的值，使用：*。
package main
import "fmt"
func main() {
i := 10
var p *int = &i
fmt.Println(p, *p)
}
（2）数组-值类型
见数组章节
（3）结构体（struct）-值类型
见结构体章节
（4）管道（Channel）-引用类型
（5）函数
见函数章节
（6）切片（slice）-引用类型
见切片章节
（7）接口（interface）-引用类型
见接口章节
（8）map-引用类型
见nmap章节
3）值类型与引用类型
（1）值类型：变量直接存储值，内存通常在栈中分配。都有对应的指针类型，形式未*数据类型，比如int的对应的指针就是*int，依次类推。
（2）引用类型：变量存储的是一个地址，这个地址对应的空间才是真正存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。
7、函数
1）函数声明
函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。
func name(parameter-list) (result-list) {
body
}
形式参数列表描述了函数的参数名以及参数类型。这些参数作为局部变量，其值由参数调用者提供。返回值列表描述了函数返回值的变量名以及类型。如果函数返回一个无名变量或者没有返回值，返回值列表的括号是可以省略的。如果一个函数声明不包括返回值列表，那么函数体执行完毕后，不会返回任何值。
函数的类型被称为函数的签名。如果两个函数形式参数列表和返回值列表中的变量类型一一对应，那么这两个函数被认为有相同的类型或签名。形参和返回值的变量名不影响函数签名，也不影响它们是否可以以省略参数类型的形式表示。
每一次函数调用都必须按照声明顺序为所有参数提供实参（参数值）。在函数调用时，Go语言没有默认参数值，也没有任何方法可以通过参数名指定形参，因此形参和返回值的变量名对于函数调用者而言没有意义。
在函数体中，函数的形参作为局部变量，被初始化为调用者提供的值。函数的形参和有名返回值作为函数最外层的局部变量，被存储在相同的词法块中。
实参通过值的方式传递，因此函数的形参是实参的拷贝。对形参进行修改不会影响实参。但是，如果实参包括引用类型，如指针，slice(切片)、map、function、channel等类型，实参可能会由于函数的间接引用被修改。
你可能会偶尔遇到没有函数体的函数声明，这表示该函数不是以Go实现的。这样的声明定义了函数签名。
2）init函数
3）Deferred函数
见异常处理章节
4）匿名函数
5）闭包
6）
8、包
包的本质就是创建不同的文件夹来存放程序文件。每个包一般都定义了一个不同的名字空间用于它内部的每个标识符的访问。每个名字空间关联到一个特定的包，让我们给类型、函数等选择简短明了的名字，这样可以在使用它们的时候减少和其它部分名字的冲突。每个包还通过控制包内名字的可见性和是否导出来实现封装特性。通过限制包成员的可见性并隐藏包API的具体实现，将允许包的维护者在不影响外部包用户的前提下调整包的内部实现。通过限制包内变量的可见性，还可以强制用户通过某些特定函数来访问和更新内部变量，这样可以保证内部变量的一致性和并发时的互斥约束。当我们修改了一个源文件，我们必须重新编译该源文件对应的包和所有依赖该包的其他包。
1）包的三大作用
（1）区分相同名字的函数、变量等标识符
（2）当程序文件很多时，可以很好的管理项目
（3）控制函数、变量等访问范围，即作用域
2）包的相关说明
（1）打包基本语法/声明基本语法
package 包名
在每个Go语言源文件的开头都必须有包声明语句。包声明语句的主要目的是确定当前包被其它包导入时默认的标识符（也称为包名）。
（2）引入包的基本语法
import "包的路径"
每个包是由一个全局唯一的字符串所标识的导入路径定位。出现在import语句中的导入路径也是字符串。（在import包时，路径从$GOPATH的src下开始，不用带src。）
_来重命名导入的包。像往常一样，下划线_为空白标识符，并不能被访问。
import _ "image/png" // register PNG decoder
9、数组
数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化。
1）基本介绍（定义和初始化）
定义：var 数组名 [数组大小]数据类型
以下是四种数组初始化方式：
默认情况下，数组的每个元素都被初始化为元素类型对应的零值，对于数字类型来说就是0。我们也可以使用数组字面值语法用一组值来初始化数组：
var q [3]int = [3]int{1, 2, 3}
var r = [3]int{1, 2}
p := [3]int{1, 2}
fmt.Println(r[2]) // "0"
在数组字面值中，如果在数组的长度位置出现的是“...”省略号，则表示数组的长度是根据初始化值的个数来计算。因此，上面q数组的定义可以简化为：
b := [...]int{1, 2, 3}
var c = [...]int{1, 2, 3}
fmt.Println(b[2])
fmt.Println(c[2])
可以指定元素值对应的下标：
var names=[3]string{1:"tom",0:"jack",2:"marry"}
数组的长度是数组类型的一个组成部分，因此[3]int和[4]int是两种不同的数组类型。数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。
2）数组遍历
（1）常规遍历
package main
import "fmt"
func main() {
var score [5]float64 = [5]float64{1.0, 2.0, 3.0, 4.0, 5.0}
for i := 0; i < len(score); i++ {
fmt.Println(score[i])
}
}
（2）for-range结构遍历
这个是go语言一种独有的结构，可以用来遍历访问数组的元素，
基本语法：for index,value:=range array01{}
第一个返回值index是数组的下标，第二个value是在该下标位置的值，它们都是仅在for循环内部可见的局部变量，遍历数组元素的时候如果不想使用下标index，可以直接把下标index标记为下划线_，index和value的名称是不固定的，也可以自行指定。
package main
import "fmt"
func main() {
var score [5]float64 = [5]float64{1.0, 2.0, 3.0, 4.0, 5.0}
for index, value := range score {
fmt.Println(index, value)
}
}
10、切片
1）基本介绍
Slice（切片）代表变长的序列，序列中每个元素都有相同的类型。一个slice类型一般写作[]T，其中T代表slice中元素的类型；slice的语法和数组很像，只是没有固定长度而已。
数组和slice之间有着紧密的联系。一个slice是一个轻量级的数据结构，提供了访问数组子序列（或者全部）元素的功能，而且slice的底层确实引用一个数组对象。一个slice由三个部分构成：指针、长度和容量。指针指向第一个slice元素对应的底层数组元素的地址，要注意的是slice的第一个元素并不一定就是数组的第一个元素。长度对应slice中元素的数目；长度不能超过容量，容量一般是从slice的开始位置到底层数据的结尾位置。内置的len和cap函数分别返回slice的长度和容量。
2）切片定义的基本语法：
var 变量名 []类型
例如：
package main
func main() {
var intArr [5]int = [...]int{1, 2, 3, 4, 5}
myslice:=[]intArr[1:4]
}
3）切片的使用
（1）方式一：定义一个切片，然后让切片去引用一个已经创建好的数组。
（2）方式二：通过make来创建切片。
基本语法：var 切片名 []type=make([]type,len,[capacity])
参数说明：type：切片的类型，len：长度，capacity：容量（可选的）。
package main
import "fmt"
func main() {
var myslice []int = make([]int, 4)
myslice[0] = 100
fmt.Println(myslice)
}
（3）方式三：
11、map
在Go语言中，一个map就是一个哈希表的引用，map类型可以写为map[K]V，其中K和V分别对应key和value。map中所有的key都有相同的类型，所有的value也有着相同的类型，但是key和value之间可以是不同的数据类型。其中K对应的key必须是支持==比较运算符的数据类型，所以map可以通过测试key是否相等来判断是否已经存在。虽然浮点数类型也是支持相等运算符比较的，但是将浮点数用做key类型则是一个坏的想法，最坏的情况是可能出现的NaN和任何浮点数都不相等。对于V对应的value数据类型则没有任何的限制。
内置的make函数可以创建一个map：
ages := make(map[string]int) // mapping from strings to ints
我们也可以用map字面值的语法创建map，同时还可以指定一些最初的key/value：
ages := map[string]int{
"alice": 31,
"charlie": 34,
}
这相当于：
ages := make(map[string]int) ages["alice"] = 31 ages["charlie"] = 34
因此，另一种创建空的map的表达式是map[string]int{}。
使用内置的delete函数可以删除元素：
delete(ages, "alice") // remove element ages["alice"]
12、结构体
结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。用结构体的经典案例是处理公司的员工信息，每个员工信息包含一个唯一的员工编号、员工的名字、家庭住址、出生日期、工作岗位、薪资、上级领导等等。所有的这些信息都需要绑定到一个实体中，可以作为一个整体单元被复制，作为函数的参数或返回值，或者是被存储到数组中，等等。
下面两个语句声明了一个叫Employee的命名的结构体类型，并且声明了一个Employee类型的变量dilbert：
type Employee struct {
ID int
Name string
Address string
DoB time.Time
Position string
Salary int
ManagerID int
}
var dilbert Employee
赋值：
type Point struct{ X, Y int }
p := Point{1, 2}
var q Point = Point{12, 12}
13、方法
在函数声明时，在其名字之前放上一个变量，即是一个方法。这个附加的参数会将该函数附加到这种类型上，即相当于为这种类型定义了一个独占的方法。
package main
import (
"fmt"
"math"
)
type Point struct{ x, y float64 }
//func
func Distance(p, q Point) float64 {
return math.Hypot(q.x-p.x, q.y-p.y)
}
//method
func (p Point) Distance(q Point) float64 {
return math.Hypot((q.x - p.x), q.y-p.y)
}
func main() {
var p Point = Point{12, 12}
var q Point = Point{8, 8}
x := Distance(p, q)
//function call
fmt.Println(x)
//method call
y := p.Distance(q)
fmt.Println(y)
}
上面的代码里那个附加的参数p，叫做方法的接收器（receiver），早期的面向对象语言留下的遗产将调用一个方法称为“向一个对象发送消息”。在Go语言中，我们并不会像其它语言那样用this或者self作为接收器；我们可以任意的选择接收器的名字。由于接收器的名字经常会被使用到，所以保持其在方法间传递时的一致性和简短性是不错的主意。这里的建议是可以使用其类型的第一个字母，比如这里使用了Point的首字母p。
在方法调用过程中，接收器参数一般会在方法名之前出现。这和方法声明是一样的，都是接收器参数在方法名字之前。
14、接口
15、错误处理机制
package main
import "fmt"
func test() {
//使用defer +recover来捕获和处理异常
defer func() {
err := recover()
if err != nil { //说明捕获到异常
fmt.Println("err:", err)
}
}()
num1 := 10
num2 := 0
res := num1 / num2
fmt.Println("rest=", res)
}
func main() {
test()
fmt.Println("main()...")
}
4）自定义错误
使用errors.New和panic内置函数
（1）errors.New("错误说明")，会返回一个error类型的值，表示一个错误。
（2）panic内置函数，接收一个interface{}类型的值（也就是任何值）作为参数。可以接收error类型的变量，输出错误信息，并退出程序。
（3）示例
package main
import (
"errors"
"fmt"
)
func readConf(name string) (err error) {
if name == "config.ini" {
return nil
} else {
return errors.New("读取文件错误...")
}
}
func test() {
err := readConf("config.in1i")
if err != nil {
panic(err)
}
fmt.Println("test()...")
}
func main() {
test()
}