一、前言
当我们项目较为简单时，我们在src目录下新建一个该项目目录，里面存放源码文件即可，见下图：
当我们一个项目较为复杂时，我们可以在src目录下新建一个该项目目录，在针对该项目不同模块创建不同目录，比如说logic（逻辑）、views（图片渲染）、data（数据库）等等。
二、第一个Go程序hello world
2.1 代码
package main import (
"fmt"
) //程序执行的入口函数
func main() {
fmt.Print("hello world")
fmt.Printf("hello world,%d\n ", 100)
fmt.Println("hello world")
}
2.2 相关解释
♦ go语言中所有的代码（源码）不能够单独存在，必须隶属于一个包。例：第一行package main表示hello.go属于main包的。
♦ 如果是为了将代码编译成一个可执行程序，那么package必须是main；如果是为了将代码编译成库，那么package则没有限制。
♦ fmt 是go的一个系统库，所以如果我们要使用这个系统库就需要将fmp这个包导入，才能引用这个包中的函数和方法，而println就是fmt库中的一个函数，fmt.println()可以打印输出。
♦ go语言中，很多东西都是强制性的，需要去慢慢习惯。对于python等解释性语言，在函数中随便写一些语句，就可以执行了，但go不行，go语言中，程序执行的入口就是main函数（当编译完后，就是一个可执行程序，可双击执行，可执行程序的入口就是执行main函数中的内容）。
♦ 注意：go语言中函数的花括号“{”一定要放在函数名所在行的行末。此处为强制性要求。
♦ fmt库中，print表示打印内容，printf表示格式化输出（%d表示占位符，指的是整型int，\n表示换行），println表示换行输出。
2.3 编译并执行
1、在当前终端中编译该程序实例
无任何输出是好事，表示程序无问题。
2、我们可以发现在当前目录已经出现了一个可执行程序
hello.exe就是编译后生成的可执行程序文件。
3、我们可以在当前终端目录下直接执行该可执行程序（windows环境也可以直接去所在目录双击执行即可）。
2.4 其他案例
上述hello world当我们在windows环境双击执行时，会发现打开后就退出了，这是正常的，程序执行完自然就退出了。此处我们我来写一个等待用户输入之后，在退出的小例子。
注意：print是打印（输出），而此处我们是要输入，用到scan，因为是输入，所以要定义一个变量来接收输入的这个值。
package main import (
"fmt"
) //程序执行的入口函数
func main() {
fmt.Print("hello world")
fmt.Printf("hello world,%d\n ", 100)
fmt.Println("hello world") var a int
fmt.Scan(&a) //等待用户输入然后退出
}
执行后的结果：
三、go基本命令介绍
基本命令
♦ go run 快速执行go文件，就像执行脚本一样（先编译（编译好文件放在一个临时文件下）在执行。注意：需指定要编译的源码文件）
♦ go build 编译程序，生成二进制可执行文件（将当前目录下所有源码编译）
♦ go install 安装可执行文件到bin目录（编译并安装，针对当前目录下所有源码）
♦ go test 执行单元测试或压力测试
♦ go env 显示go相关的环境变量
♦ go fmt 格式化源代码（当我们从网络上找了些源码格式混乱时，需要针对该源码文件打开终端执行gofmt –w .）
一般来说我们的ide在我们保存时就已经将代码格式化了。
补充：
1、GOPATH下全路径编译
当处于GOPATH路径下进行编译时，要写源代码所在全路径时，不用写src，因为go中已经固定死了（默认就是往src目录下去找）。情况如下图所示（图中GOPATH为d:\project）：
go intsall同go build一模一样。
四、go的程序结构
4.1 关于注释
单行注释：//
多行注释：/* */
4.2
程序结构
♦ 一个项目（目录）下所有代码文件应只属于一个包（多个会报错）,也就是说一个目录下写的是一个大的功能，这些个功能只能归属于一个包。
♦ go源码按package进行组织，并且package要放到非注释的第一行
♦ 一个程序（代码）只有一个main函数
♦ main函数是程序的执行入口
♦ 代码是可执行程序，那么package必须是main，包是main是定死的，函数也必须是main也是定死的，否则就会报错（因为package已经声明了是main，那就表明这是可执行程序，如果此时函数不是main那就会报错。）package（包） main 和func（函数）main是一一对应的。
可参考下图更好理解main。
4.3 包的概念
1. 和python一样，把相同功能的代码放到一个目录，称之为包
2. 包可以被其他包引用
3. main包是用来生成可执行文件，每个程序只有一个main包
4. 包的主要用途是提高代码的可复用性
五、标识符和关键字
1、标识符是用来表示Go中的变量名或者函数名，以字母或_开头。后面跟着字母、 _或数字
如：_ab28 和ab_28就是合法的，88ab就是不合法的。
2、关键字是Go语言预先定义好的，有特殊含义的标识符。
六、变量和常量
6.1 变量
语法：var identifier type
var 变量名 变量类型
变量名 = 值
注意：
1、go语言中定义的变量必须被用到，否则会报错（但是也有解决办法：如果定义的变量d未被用到，我们可以使用 _ = d 来忽略变量d）
2、同时定义变量和赋值可以一步完成。
3、type可以省略不写，系统会自动根据后面给定的值进行判别
4、Go语言中变量命名推荐驼峰语法
例1：
var a int
var b string
var c bool
var d int = 8
var e string = "hello"
我们会发现当定义多个变量会显得很繁琐，每一个都必须写var，其实可以不用每个都写，具体见例2.
例2：
var (
a int //0 不赋值默认为0
b string //“” 不赋值默认为空
c bool //false 不赋值默认为false
d int = 8 // 8
e string = "hello" //hello
)
例3打印变量小案例：
将上述定义的变量打印出来
package main import (
"fmt"
) var (
a int //0 不赋值默认为0
b string //“” 不赋值默认为空
c bool //false 不赋值默认为false
d int = 8 // 8
e string = "hello" //hello
) func main() {
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
}
执行结果：
补充：
var a int =10 可以简写为 a :=10（:=表示声明并初始化变量）
6.2 常量
常量使用const 修饰，代表永远是只读的，不能修改。
语法：
const identifier [type] = value，其中type可以省略。
实例6-1 例1：常规写法
const b string = "hello world"
const b = "hello world"
const Pi = 3.1414926
const a = 9/3
实例6-2 例2：优雅写法
const(
a = 1
b = 2
c = 3
)
实例6-3 例3：专业写法1
如果我们上述定义的的常量a、b、c是有序的，我们可以使用下面的专业写法
const (
a = iota
b = iota
c = iota
)
# iota表示自动从0开始，第一行为0（以行为单位，和行数绑定，第一行为0，第二行为1，第三行为2），往后递增。a=0,b=1,c=2
简写为如下：一般用简写
const (
a = iota
b
c
)
注意：iota是与行数相绑定的，与行号相关，下面这个例子来加深印象
package main import (
"fmt"
) const (
a = 5
b = iota
c
d = 3
e
f
g = iota
) func main() {
fmt.Printf("a=%d b=%d c=%d d=%d e=%d f=%d g=%d", a, b, c, d, e, f, g)
}
执行结果：
解释：
第一行a=5
第二行b=iota，因为是第二行了了所以b=1（第一行iota=0，第二行iota=1）
第三行c，因为第二行是b = iota，所以相邻c = iota，所以c=2
第四行d=3
第五行e相邻d=3，所以e=3
第六行f也是等于3
第七行g=iota，因为是第7行了所以g=6（注意第一行是以0开始而不是1）
实例6-4 例4 专业写法2
const(
a = 1 << iota
b
c
)
#iota可以方便的迭代一个值从0以步长1递增，0,1,2,3,4,5…
结果：a=1,b=2,c=4
七、数据类型和操作符
7.1 布尔类型
a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符
e. 格式化输出占位符: %t
实例7-1
package main import (
"fmt"
) func main() {
var b = false
var (
c = true
d bool = false
) _ = d //因为此程序d变量没有用到，此处我们将d变量赋值给_，_就相当于忽略的意思 if !b {
fmt.Printf("b is false\n")
}
if !b && c {
fmt.Printf("result is true\n")
} /*
if b || c == true { }
*/
if b || c {
fmt.Printf("or operation\n")
}
}
执行结果如下：
7.2 整数和浮点数类型
a. 符号：int8（1字节）、int16（2字节）、int32（4字节）、int64（8字节）
b. 无符号：uint8、uint16、uint32、uint64
c. int和uint和操作系统平台相关（比如说：64位系统占8字节，32位系统占4字节，所以如果跨平台的话最好采用a和b带数字下标的形式，这样可扩展性比较好）
d. float32（4字节）和float64（8字节）浮点类型
e. 所有整数初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false
f. Go是强类型语言，不同类型相加以及赋值是不允许的（比如说：定义为int，永远是int类型。int和int32是不同类型，不能相加也不能互相赋值）
g. 那怎么样才能实现，不同类型相加呢？
比如：int和int32类型想要相加，那必须得做一个强制转换，转换成相同类型数据才能相加或者赋值
h. 输出占位符：整数%d， %x十六进制， %f浮点数
补充：
1字节===8个二进制位===11111111 相当于最大值256（2^8） 如果有符号的话最大值是127
实例7-2
package main import (
"fmt"
) func main() {
var a int = 10
var b int32 = 10
var c int c = a + int(b) var d int = int(b)
fmt.Print(a, b, c, d)
fmt.Println() //不输出任何值表示换行
fmt.Printf("%x\n", c) //输出16进制c
}
执行结果：
7.3 字符串类型
a. var str string
b. var str string = “hello world”
c. 字符串输出占位符%s
d. 万能输出占位符: %v （当不确定数据具体是什么类型时，用什么占位符时，系统自动帮我们进行转换。）
package main import (
"fmt"
) func main() {
var b string = "hello"
var c = "hello" fmt.Printf("b=%v and c=%s\n", b, c)
}
执行结果：
7.4 字符串的两种表示方式
a. 双引号， “”，可以包含控制字符
b. 反引号， ``，所有字符都是原样输出
c．字符必须用单引号括起来，不能用双引号，字符串用双引号。
实例7-3
package main import (
"fmt"
) func main() {
var str = "hello world\n\n" // \n是控制字符换行，""的话可以包含控制字符，输出换行
var str2 = `hello \n \n \n` // ``所有字符都会原样输出 fmt.Println("str=", str)
fmt.Println("str2=", str2)
}
输出结果：
实例7-4
package main import (
"fmt"
) func test_str1() {
var b string = "hello\n\n\n"
var c = "hello" fmt.Printf("b=%v and c = %s\n", b, c)
}
func test_str2() {
var b string = `
床前明月光\n，
疑是地上霜。
举头望明月，
低头思故乡。
` fmt.Printf("b %s\n", b)
}
func test_char() {
var c rune //rune用来表示一个utf8的字符
c = 20320
var d byte //byte表示一个字节
d = 'd'
//c = '你' //'你'的utf8编码是20320，所以下面代码输出‘你’
var e rune = '喊'
fmt.Printf("c=%c d=%c e=%c\n", c, d, e) // %c输出字符
}
func main() {
test_str1()
test_str2()
test_char()
}
输出结果：
补充：go语言中支持以下格式输出。
目前printf支持以下格式的输出，例如：
printf("%c",a)；输出单个字符。
printf("%d",a)；输出十进制整数。
printf("%f",a)；输出十进制浮点数.
printf("%o",a)；输出八进制数。
printf("%s",a)；输出字符串。
printf("%u",a)；输出无符号十进制数。
printf("%x",a)；输出十六进制数。
7.5 操作符
a. 逻辑操作符， == 、 != 、 <、 <=、 >=
b. 算数操作符， +、 -、 *、 /、 %
八、 Go程序的基本结构延伸
1. 任何一个代码文件隶属于一个包
2. import 关键字，引用其他包：
import "fmt"
import("os")
通常习惯写成：
import (
"fmt"
"os"
)
3. 开发可执行程序， package main，
并且有且只有一个main入口函数。
4. 包中函数调用：
a. 同一个包中函数，直接用函数名调用
b. 不同包中函数，通过包名+点+函数名进行调用
5. 包访问控制规则：
a. 大写意味着这个函数/变量是可导出
b. 小写意味着这个函数/变量是私有的,包外部不能访问
实例8-1
目录结构：
calc：做第三方库
calc.go
package calc import (
"fmt"
) func Add(a int, b int) int {
var c = a + b
fmt.Printf("add result:%d\n", c)
return c
}
编译安装为静态库：
编译后的静态库：（main包为可执行包，编译后的文件为.go后缀二进制文件，main之外的包，编译后存在pkg下，后缀为.a文件）
可执行程序main.go
package main import (
"day1/calc"
"fmt"
) func main() {
var c int
c = calc.Add(2, 3)
fmt.Printf("c=%d\n", c)
}
执行结果：
九、 Go语言特性
1. 垃圾回收
a. 内存自动回收，再也不需要开发人员管理内存
b. 开发人员专注业务实现，降低了心智负担
c. 只需要new分配内存，不需要释放
2. 天然并发
a. 从语言层面支持并发，非常简单（用户态实现，避免了用户态和内核态的频繁切换）
b. goroutine（协程），轻量级线程，创建成千上万个goroute成为可能（go成千上万个goroutine在用户态跑时，可能操作系统（内核）只有几千个线程再跑，java有多少个线程在用户态跑，就有多少个线程在内核态跑）
c. 基于CSP（Communicating Sequential Process）模型实现（其实就是goroutine+channel，线程之间通信借助管道）
实例9-1
原有程序案例是：
calc.go
package calc import (
"fmt"
) func Add(a int, b int) int {
var c = a + b
fmt.Printf("add result:%d\n", c)
return c
}
main.go 示例1
package main import (
"day1/calc"
"fmt"
) func main() {
var c int
calc.Add(2, 3)
fmt.Printf("c=%d\n", c)
}
目前是同步执行的，如果想要异步执行，只需要如下（标红）操作即可，那样就变成多线程的了，代码示例如下：
main.go
示例2：
package main import (
"day1/calc"
"fmt"
) func main() {
var c int
go calc.Add(2, 3)
fmt.Printf("c=%d\n", c)
}
接下来演示效果：
如果是单线程跑，代码示例如示例1：执行结果如下：
解释：单线程跑的话，是同步的，先调函数打印出加法计算结果，然后在打出c的值。单线程是顺序输出，固定输出的。
如果是多线程跑，代码示例如示例2：实行结果如下：
解释：
go calc.Add(2, 3) 相当于起了一个线程再跑，fmt.Printf("c=%d\n", c)，是另一个线程（主线程）再跑，为什么最后只打印出一个c=0，是因为主线程执行完了，退出了，其他的线程就没有机会执行了。多线程是哪一个线程调度的快，哪一个线程就优先输出，主线程优先输出的话，其他线程就没有机会执行了。
3. channel
a. 管道，类似unix/linux中的pipe（队列）
b. 多个goroute之间通过channel进行通信
c. 支持任何类型
实例9-2
package main import (
"fmt"
) func main() {
p := make(chan int, 3)
p <- 1
p <- 2 var b int
b = <-p
fmt.Printf("b = %d\n", b)
}
输出结果：
解释：
make（chan int,3）：chan就是管道类型关键字，int表示管道中放什么类型数据，3表示管道空间，也就是管道的容量
p <- 1：就表示往管道中放数据
b = <- p：表示从管道中把数据取出来给变量b
输出的b的结果为1:，是因为队列先进先出。
注意:
管道容量为3，当放入的数据多于3个时，就会报死锁的错误。
代码如下：
执行结果：
死锁是最近新版本加入，旧的版本会直接卡在哪里等待。
4. 多返回值
a. 一个函数返回多个值
实例9-3
定义多个返回值，就要返回多个，不然会报错，都是一一对应的。
实例9-4
package main import (
"fmt"
) func Calc(a int, b int) (int, int) {
return a + b, a - b
} func main() {
a1, b1 := Calc(2, 5)
fmt.Printf("a1=%d b1=%d\n", a1, b1)
}
执行结果：
