李文周的博客 | 总结Go语言学习之路，提供免费的Go语言学习教程，希望与大家一起学习进步。 (liwenzhou.com)
一、Window下载安装
安装包下载地址（下面3个都可以）：
选择稳定版下载，如：go1.18.9.windows-amd64.msi，然后双击无脑下一步即可
执行一下命令检测是否安装成功
go version二、go介绍
1、go简介
Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率 ，使用一个表达式来形容 Go 语言：Go = C + Python , 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发。
Golang 官方网站(可能访问不了): https://golang.org
Golang 中文网 在线标准库文档： https://studygolang.com/pkgdoc
- 从 C 语言中继承了很多理念，包括表达式语法，控制结构，基础数据类型，调用参数传值，指针等等，也保留了和 C 语言一样的编译执行方式及弱化的指针
//go 语言的指针的使用特点(体验)
func testPtr(num *int) {
*num = 20
}- 引入包的概念，用于组织程序结构，Go 语言的一个文件都要归属于一个包，而不能单独存在。
package main //一个文件都要归属于一个包
import "fmt"
func main() {
fmt.Println("hello word")
}- 垃圾回收机制，内存自动回收，不需开发人员管理
- 天然并发 (重要特点)
- 从语言层面支持并发，实现简单
- goroutine，轻量级线程，可实现大并发处理，高效利用多核。
- 基于 CPS 并发模型(Communicating Sequential Processes )实现
- 吸收了管道通信机制，形成 Go 语言特有的管道 channel 通过管道 channel , 可以实现不同的 goroute之间的相互通信。
- 函数可以返回多个值。举例：
//写一个函数，实现同时返回 和，差
//go 函数支持返回多个值
func getSumAndSub(n1 int, n2 int) (int, int ) {
sum := n1 + n2 //go 语句后面不要带分号.
sub := n1 - n2
return sum , sub
}- 新的创新：比如切片 slice、延时执行 defer
2、开发注意事项
Go 源文件以 “go” 为扩展名。
Go 应用程序的执行入口是 main()函数。 这个是和其它编程语言（比如 java/c）一样
Go 语言严格区分大小写。
Go 方法由一条条语句构成，每个语句后不需要分号(Go 语言会在每行后自动加分号)，这也体现出 Golang 的简洁性。
Go 编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
go 语言定义的变量或者 import 的包如果没有使用到，代码不能编译通过。
大括号都是成对出现的，缺一不可。
三、程序启动
1、goPath 启动
Goland 创建项目配置 GoPath
编写 main.go
package main
import "fmt"
func main() {
fmt.Println("hello world!!")
}可直接在 Goland 编译运行，也可用下面的命令运行
go run .\main.goGOPATH 是早期的设置方式，将工作目录设置 GOPATH 到全局环境变量。
不同的项目都在 GOPATH/src/ 下。很显然这种设置方法是不太方便的，因为不同项目引用的 package 到放到了一起，这用 git 管理起来很麻烦，比如Ａ项目引用了 a,b 两个 package，B 项目引用了 c,d 两个 package，那么如果我在 A 中修改了 package 的内容，我提交Ａ项目时想要带着 package 时就很麻烦。
其次是 GOPATH 需要设置全局环境变量，很多新手在对这些不熟悉的时候，很容易出错。项目名也必须不同。否则无法区分。
2、Go Modules
go modules是 golang 1.11引入的新特性。模块是相关Go包的集合。modules是源代码交换和版本控制的单元。 go命令直接支持使用modules，包括记录和解析对其他模块的依赖性。modules替换旧的基于GOPATH的方法来指定在给定构建中使用哪些源文件。
GO111MODULE有三个值：off、on 和 auto(默认值)
GO111MODULE=off，无模块支持，go 会从 GOPATH 和 vendor 文件夹寻找包
GO111MODULE=on，模块支持，go 会忽略 GOPATH 和 vendor 文件夹，只根据 go.mod 下载依赖
GO111MODULE=auto，在 $GOPATH/src 外面且根目录有 go.mod 文件时，开启模块支持
在使用模块的时候，GOPATH 是无意义的，不过它还是会把下载的依赖储存在 $GOPATH/src/mod 中，也会把 go install 的结果放在 $GOPATH/bin 中。
GOPROXY
由于中国政府的网络监管系统，Go 生态系统中有着许多中国 Gopher 们无法获取的模块，比如最著名的 golang.org/x/…。并且在中国大陆从 GitHub 获取模块的速度也有点慢。因此需要配置GOPROXY来加速Module依赖下载，这里使用goproxy.cn代理，详细介绍：传送门
Go 1.13及以上版本
go env -w GOPROXY=https://goproxy.cn,directGo 1.13以下的版本
export GOPROXY=https://goproxy.cn注: 推荐将 GO111MODULE 设置为on 而不是auto
3、Go Mod启动
go mod 正是为了解决 GoPath 问题（并不单单是上述问题，还有依赖引用问题）。在 1.13 以后开始推行。因为没多长时间，所以现在网络上的教程两种版本的都有，很容易混淆。
go mod 可以完全替代 GOPATH 设置。只需要 go env -w GO111MODULE=on 开启 go mod
GOPATH 与 Go mod 两种模式是不兼容的，建议使用 Go mod 模式就好。
go path 所有运行的go文件都要放在gopath文件下 因为下载下来的包都在这里目录下 可以引用，类似Maven，go.mod 文件就类似于 maven 的 pom.xml
Go Mod 相关命令
go mod
The commands are:
download download modules to local cache (下载依赖的module到本地cache))
edit edit go.mod from tools or scripts (编辑go.mod文件)
graph print module requirement graph (打印模块依赖图))
init initialize new module in current directory (再当前文件夹下初始化一个新的module, 创建go.mod文件))
tidy add missing and remove unused modules (增加丢失的module，去掉未用的module)
vendor make vendored copy of dependencies (将依赖复制到vendor下)
verify verify dependencies have expected content (校验依赖)
why explain why packages or modules are needed (解释为什么需要依赖)（1）初始化新项目
名称是模块的模块路径。在大多数情况下，这将是保存源代码的存储库位置，例如 github.com/mymodule。如果你计划发布你的模块供其他人使用，模块路径必须是Go工具可以下载你的模块的位置。
go mod init example.com/hellomain.go
package main
import "fmt"
func main() {
fmt.Println("hello world!!")
}运行
go run .（2）更新依赖
package main
import "fmt"
import "rsc.io/quote"
func main() {
fmt.Println("hello world!!")
fmt.Println(quote.Go())
}加入新的依赖，执行一下命令，更新依赖
go mod tidy4、运行程序
go run hello.go此外我们还可以使用 go build 命令来生成可执行二进制文件：
go build hello.go执行生成的 hello 文件（window 下 生成 .exe 文件）
./hello5、hello world 解析
package main
import "fmt"
func main() {
/* 这是我的第一个简单的程序 */
fmt.Println("hello world!!")
}- 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
- 下一行 import “fmt” 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
- 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
- 下一行 /…/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
- 下一行 fmt.Println(…) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
使用 fmt.Print(“hello, world\n”) 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。 - 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
需要注意的是 { 不能单独放在一行
四、基础语法
1、行分隔符
在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。
如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。
以下为两个语句：
fmt.Println("Hello, World!")
fmt.Println("菜鸟教程：runoob.com")实测 1.18.9 下，一下写法均可
fmt.
Println(quote.Go())
fmt.Println(
quote.Go(),// 注意需要逗号
)2、注释
注释不会被编译，每一个包应该有相关注释。
单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。如：
// 单行注释
/*
我是多行注释
*/3、标识符
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
4、字符串连接与格式化
Go 语言的字符串连接可以通过 + 实现：
fmt.Println("Google" + "Runoob")Go 语言中使用 fmt.Sprintf 或 fmt.Printf 格式化字符串并赋值给新串：
- Sprintf 根据格式化参数生成格式化的字符串并返回该字符串。
- Printf 根据格式化参数生成格式化的字符串并写入标准输出。
Sprintf 实例
package main
import (
"fmt"
)
func main() {
// %d 表示整型数字，%s 表示字符串
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
var target_url=fmt.Sprintf(url,stockcode,enddate)
fmt.Println(target_url)
}输出结果为：
Code=123&endDate=2020-12-31Printf 实例
package main
import (
"fmt"
)
func main() {
// %d 表示整型数字，%s 表示字符串
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
fmt.Printf(url,stockcode,enddate)
}输出结果为：
Code=123&endDate=2020-12-315、关键字
下面列举了 Go 代码中会使用到的 25 个关键字或保留字：
| break | default | func | interface | select |
|---|---|---|---|---|
| case | defer | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrough | if | range | type |
| continue | for | import | return | var |
除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：
| append | bool | byte | cap | close | complex | complex64 | complex128 | uint16 |
|---|---|---|---|---|---|---|---|---|
| copy | false | float32 | float64 | imag | int | int8 | int16 | uint32 |
| int32 | int64 | iota | len | make | new | nil | panic | uint64 |
| println | real | recover | string | true | uint | uint8 | uintptr |
6、空格
在 Go 语言中，空格通常用于分隔标识符、关键字、运算符和表达式，以提高代码的可读性。
Go 语言中变量的声明必须使用空格隔开，如：
var x int
const Pi float64 = 3.14159265358979323846在运算符和操作数之间要使用空格能让程序更易阅读：
无空格：
fruit=apples+oranges;在变量与运算符间加入空格，程序看起来更加美观，如：
fruit = apples + oranges; 在关键字和表达式之间要使用空格。
例如：
if x > 0 {
// do something
}在函数调用时，函数名和左边等号之间要使用空格，参数之间也要使用空格。
例如：
result := add(2, 3)五、变量
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
注意：golang中根据首字母的大小写来确定可以访问的权限。无论是方法名、常量、变量名还是结构体的名称。如果首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用
声明变量的一般形式是使用 var 关键字：
var 变量名 变量类型可以一次声明多个变量：
var 变量名1, 变量名2 变量类型初始化值的方式（自动根据值的类型赋予变量类型）
var 变量名 = 变量值1、无初始值
指定变量类型，如果没有初始化，则变量默认为零值。
package main
import "fmt"
func main() {
// 声明一个变量并初始化
var a = "RUNOOB"
fmt.Println(a) // RUNOOB
// 没有初始化就为零值
var b int
fmt.Println(b) // 0
// bool 零值为 false
var c bool
fmt.Println(c) // false
}- 数值类型（包括complex64/128）为 0
- 布尔类型为 false
- 字符串为 **””**（空字符串）
- 以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口2、有初始值
var 变量名 = 变量值package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}3、短变量声明法
在函数内部可以使用 := 进行声明变量并赋予初始化值
注意：短变量声明法只能用于声明局部变量，不能用于全局变量的声明
var intVal int
intVal = 1
// 上面的两句可以简写为
intVal := 14、多变量声明(并行赋值)
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)示例
package main
import "fmt"
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
fmt.Println(x, y, a, b, c, d, e, f, g, h)
}并行赋值
a, b, c := 5, 7, "abc"右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 “abc”。
这被称为 并行 或 同时 赋值。
并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。
5、值类型和引用类型
类似 java ，基本数据类型是值拷贝，引用类型是地址拷贝
所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值
当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝
你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。
值类型变量的值存储在堆中。
内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。
更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。
这个内存地址称之为指针，这个指针实际上也被存在另外的某一个值中。
同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。
当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。
如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。
6、交换变量的值
如果你想要交换两个变量的值，则可以简单地使用以下方式交换，两个变量的类型必须是相同。
a, b = b, a7、空白标识符/匿名变量
在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如：
func foo() (int, string) {
return 10, "Q1mi"
}
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 (在Lua等编程语言里，匿名变量也被叫做哑元变量。)
空白标识符 _ 也被用于抛弃值，如值 5 在以下代码中被抛弃
_, b = 5, 7_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
注意事项：
- 函数外的每个语句都必须以关键字开始（var、const、func等）
:=不能使用在函数外。_多用于占位，表示忽略值。
8、注意事项
- 局部变量申明却没有在相同的代码块中使用它，编译期会报错，而全局变量不会
- 不同类型的变量不可相互赋值
六、常量
1、基本常量
相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。
const pi = 3.1415
const e = 2.7182声明了pi和e这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。
多个常量也可以一起声明：
const (
pi = 3.1415
e = 2.7182
)const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：
const (
n1 = 100
n2
n3
)上面示例中，常量n1、n2、n3的值都是100。
2、iota
iota是go语言的常量计数器，只能在常量的表达式中使用。
iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。
举个例子：
const (
n1 = iota //0
n2 //1
n3 //2
n4 //3
)几个常见的iota示例:
使用_跳过某些值
const (
n1 = iota //0
n2 //1
_
n4 //3
)iota声明中间插队
const (
n1 = iota //0
n2 = 100 //100
n3 = iota //2
n4 //3
)
const n5 = iota //0定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）
const (
_ = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)多个iota定义在一行
const (
a, b = iota + 1, iota + 2 //1,2
c, d //2,3
e, f //3,4
)七、数据类型
0、总览
1、数值类型
| 类型 | 描述 |
|---|---|
| uint | 32位或64位 |
| uint8 | 无符号 8 位整型 (0 到 255) |
| uint16 | 无符号 16 位整型 (0 到 65535) |
| uint32 | 无符号 32 位整型 (0 到 4294967295) |
| uint64 | 无符号 64 位整型 (0 到 18446744073709551615) |
| int | 32位或64位 |
| int8 | 有符号 8 位整型 (-128 到 127) |
| int16 | 有符号 16 位整型 (-32768 到 32767) |
| int32 | 有符号 32 位整型 (-2147483648 到 2147483647) |
| int64 | 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
| byte | uint8的别名(type byte = uint8) |
| rune | int32的别名(type rune = int32)，表示一个unicode码 |
| uintptr | 无符号整型，用于存放一个指针是一种无符号的整数类型，没有指定具体的bit大小但是足以容纳指针。无符号整型，用于存放一个指针是一种无符号的整数类型，没有指定具体的bit大小但是足以容纳指针。 |
| float32 | IEEE-754 32位浮点型数 |
| float64 | IEEE-754 64位浮点型数 |
| complex64 | 32 位实数和虚数 |
| complex128 | 64 位实数和虚数 |
（1）整型数据
分为两类，有符号和无符号两种类型
有符号: int, int8, int16, int32, int64
无符号: uint, uint8, uint16, uint32, uint64, byte
不同位数的整型区别在于能保存整型数字范围的大小；
有符号类型可以存储任何整数，无符号类型只能存储自然数
int和uint的大小和系统有关，32位系统表示int32和uint32，如果是64位系统则表示int64和uint64，不能跨平台
byte与uint8类似，一般用来存储单个字符
在保证程序正确运行下，尽量使用占用空间小的数据类型
fmt.Printf(“%T”, var_name)输出变量类型unsafe.Sizeof(var_name)查看变量占用字节
注意：获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。
（2）数字字面量语法
Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：
v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。
而且还允许我们用 _ 来分隔数字，比如说： v := 123_456 表示 v 的值等于 123456。
我们可以借助fmt函数来将一个整数以不同进制形式展示。
package main
import "fmt"
func main(){
// 十进制
var a int = 10
fmt.Printf("%d \n", a) // 10
fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制
// 八进制 以0开头
var b int = 077
fmt.Printf("%o \n", b) // 77
// 十六进制 以0x开头
var c int = 0xff
fmt.Printf("%x \n", c) // ff
fmt.Printf("%X \n", c) // FF
}（3）浮点型
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。
打印浮点数时，可以使用fmt包配合动词%f，代码如下：
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}1、浮点型的存储分为三部分：符号位+指数位+尾数位
2、尾数部分可能丢失，造成精度损失。-123.0000901
3、golang的浮点型默认为float64类型
4、通常情况下，应该使用float64,因为它比float32更精确
5、0.123可以简写成 .123 ,也支持科学计数法表示: 5.1234e2 等价于 512.34
（4）复数
complex64和complex128
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。
2、布尔值
Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
注意：
- 布尔类型变量的默认值为
false。 - Go 语言中不允许将整型强制转换为布尔型.
- 布尔型无法参与数值运算，也无法与其他类型进行转换。
3、byte和rune类型
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：
var a = '中'
var b = 'x'Go 语言的字符有以下两种：
uint8类型，或者叫 byte 型，代表一个ASCII码字符。rune类型，代表一个UTF-8字符。
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。
// 遍历字符串
func traversalString() {
s := "hello沙河"
for i := 0; i < len(s); i++ { //byte
fmt.Printf("%v(%c) ", s[i], s[i])
}
fmt.Println()
for _, r := range s { //rune
fmt.Printf("%v(%c) ", r, r)
}
fmt.Println()
}输出：
104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³)
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 因为UTF8编码下一个中文汉字由3~4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。
字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。
注意事项
Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的，也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。
字符只能被单引号包裹，不能用双引号，双引号包裹的是字符串
当我们直接输出type值时，就是输出了对应字符的ASCII码值
当我们希望输出对应字符，需要使用格式化输出
Go语言的字符使用UTF-8编码，英文字母占一个字符，汉字占三个字符
在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。
可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符
字符类型是可以运算的，相当于一个整数，因为它们都有对应的unicode码
字符类型本质探讨
- 字符型存储到计算机中，需要将字符对应的码值(整数)找出来存储:字符 –> 码值 –> 二进制 –> 存储读取: 二进制 –>码值 –> 字符 –> 读取
- 字符和码值的对应关系是通过字符编码表决定的(是规定好的)
- Go语言的编码都统一成了UTF-8。非常的方便，很统一，再也没有编码乱码的困扰了
4、字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
- 字符串一旦赋值了，就不能修改了:在Go中字符串是不可变的。
Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：
s1 := "hello"
s2 := "你好"（1）字符串转义符
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。
| 转义符 | 含义 |
|---|---|
\r |
回车符（返回行首） |
\n |
换行符（直接跳到下一行的同列位置） |
\t |
制表符 |
\' |
单引号 |
\" |
双引号 |
\\ |
反斜杠 |
举个例子，我们要打印一个Windows平台下的一个文件路径：
package main
import (
"fmt"
)
func main() {
fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}（2）多行字符串
Go语言中要定义一个多行字符串时，就必须使用反引号字符：
s1 := `第一行
第二行
第三行
`
fmt.Println(s1)反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。
（3）字符串的常用操作
| 方法 | 介绍 |
|---|---|
| len(str) | 求长度 |
| +或fmt.Sprintf | 拼接字符串 |
| strings.Split | 分割 |
| strings.contains | 判断是否包含 |
| strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
| strings.Index(),strings.LastIndex() | 子串出现的位置 |
| strings.Join(a[]string, sep string) | join操作 |
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println("hello world!")
str := "1,2,3,4,5,5"
// 获取字符串长度
strLen := len(str)
fmt.Println(strLen) // 11
// 分割字符串
strArr := strings.Split(str, ",")
fmt.Println(strArr) // [1 2 3 4 5 5]
hasPrefix := strings.HasPrefix(str, "1")
fmt.Println(hasPrefix) // true
hasSuffix := strings.HasSuffix(str, "5")
fmt.Println(hasSuffix) // true
// 子串首次出现索引
index := strings.Index(str, "5")
fmt.Println(index) // 8
// 子串首次出现索引
lastIndex := strings.LastIndex(str, "5")
fmt.Println(lastIndex) //10
// 判断字符串是否包含指定字符
contains := strings.Contains(str, "1")
fmt.Println(contains) //true
}（4）修改字符串
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
s2 := "白萝卜"
runeS2 := []rune(s2)
runeS2[0] = '红'
fmt.Println(string(runeS2))
}5、类型转换
Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。
强制类型转换的基本语法如下：
T(表达式)其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.
比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制类型转换为float64类型。
func sqrtDemo() {
var a, b = 3, 4
var c int
// math.Sqrt()接收的参数是float64类型，需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)
}八、运算符
Go 语言内置的运算符有：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
1、算术运算符
| 运算符 | 描述 |
|---|---|
| + | 相加 |
| - | 相减 |
| * | 相乘 |
| / | 相除 |
| % | 求余 |
注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。
2、关系运算符
| 运算符 | 描述 |
|---|---|
| == | 检查两个值是否相等，如果相等返回 True 否则返回 False。 |
| != | 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 |
| > | 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 |
| >= | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 |
| < | 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 |
| <= | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 |
3、逻辑运算符
| 运算符 | 描述 |
|---|---|
| && | 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。 |
| || | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。 |
| ! | 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。 |
4、位运算符
位运算符对整数在内存中的二进制位进行操作。
| 运算符 | 描述 |
|---|---|
| & | 参与运算的两数各对应的二进位相与。 （两位均为1才为1） |
| | | 参与运算的两数各对应的二进位相或。 （两位有一个为1就为1） |
| ^ | 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1） |
| << | 左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。 |
| >> | 右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。 |
5、赋值运算符
| 运算符 | 描述 |
|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 |
| += | 相加后再赋值 |
| -= | 相减后再赋值 |
| *= | 相乘后再赋值 |
| /= | 相除后再赋值 |
| %= | 求余后再赋值 |
| <<= | 左移后赋值 |
| >>= | 右移后赋值 |
| &= | 按位与后赋值 |
| |= | 按位或后赋值 |
| ^= | 按位异或后赋值 |
九、流程控制
1、if-条件判断
if 表达式1 {
分支1
} else if 表达式2 {
分支2
} else{
分支3
}当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3。 if判断中的else if和else都是可选的，可以根据实际需要进行选择。
Go语言规定与if匹配的左括号{必须与if和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与else匹配的{也必须与else写在同一行，else也必须与上一个if或else if右边的大括号在同一行。
举个例子：
func ifDemo1() {
score := 65
if score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}
}if条件判断特殊写法
if条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：
func ifDemo2() {
if score := 65; score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}
}2、for-循环
Go 语言中的所有循环类型均可以使用for关键字来完成。
for循环的基本格式如下：
for 初始语句;条件表达式;结束语句{
循环体语句
}条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。
func forDemo() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}for循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：
func forDemo2() {
i := 0
for ; i < 10; i++ {
fmt.Println(i)
}
}for循环的初始语句和结束语句都可以省略，例如：
func forDemo3() {
i := 0
for i < 10 {
fmt.Println(i)
i++
}
}这种写法类似于其他编程语言中的while，在while后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。
（1）无限循环
for {
循环体语句
}for循环可以通过break、goto、return、panic语句强制退出循环。
（2）break
break语句可以结束for、switch和select的代码块。
break语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的for、switch和 select的代码块上。 举个例子：
func breakDemo1() {
BREAKDEMO1:
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
break BREAKDEMO1
}
fmt.Printf("%v-%v\n", i, j)
}
}
fmt.Println("...")
}（3）continue
continue语句可以结束当前循环，开始下一次的循环迭代过程，仅限在for循环内使用。
在 continue语句后添加标签时，表示开始标签对应的循环。例如：
func continueDemo() {
forloop1:
for i := 0; i < 5; i++ {
// forloop2:
for j := 0; j < 5; j++ {
if i == 2 && j == 2 {
continue forloop1
}
fmt.Printf("%v-%v\n", i, j)
}
}
}（4）goto
goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：
func gotoDemo1() {
var breakFlag bool
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// 设置退出标签
breakFlag = true
break
}
fmt.Printf("%v-%v\n", i, j)
}
// 外层for循环判断
if breakFlag {
break
}
}
}使用goto语句能简化代码：
func gotoDemo2() {
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// 设置退出标签
goto breakTag
}
fmt.Printf("%v-%v\n", i, j)
}
}
return
// 标签
breakTag:
fmt.Println("结束for循环")
}3、for range-键值循环
Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：
- 数组、切片、字符串返回索引和值。
- map返回键和值。
- 通道（channel）只返回通道内的值。
遍历 Map
for key, value := range oldMap {
newMap[key] = value
}
// 只获取 key
for key := range oldMap {
}
// 只获取 value
for _, value := range oldMap {
}遍历切片
import "fmt"
// 声明一个包含 2 的幂次方的切片
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
// 遍历 pow 切片，i 是索引，v 是值
for i, v := range pow {
// 打印 2 的 i 次方等于 v
fmt.Printf("2**%d = %d\n", i, v)
}
}4、switch case
使用switch语句可方便地对大量的值进行条件判断。
func switchDemo1() {
finger := 3
switch finger {
case 1:
fmt.Println("大拇指")
case 2:
fmt.Println("食指")
case 3:
fmt.Println("中指")
case 4:
fmt.Println("无名指")
case 5:
fmt.Println("小拇指")
default:
fmt.Println("无效的输入！")
}
}Go语言规定每个switch只能有一个default分支。
一个分支可以有多个值，多个case值中间使用英文逗号分隔。
func testSwitch3() {
switch n := 7; n {
case 1, 3, 5, 7, 9:
fmt.Println("奇数")
case 2, 4, 6, 8:
fmt.Println("偶数")
default:
fmt.Println(n)
}
}分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。例如：
func switchDemo4() {
age := 30
switch {
case age < 25:
fmt.Println("好好学习吧")
case age > 25 && age < 35:
fmt.Println("好好工作吧")
case age > 60:
fmt.Println("好好享受吧")
default:
fmt.Println("活着真好")
}
}fallthrough语法可以执行满足条件的case的下一个case，是为了兼容C语言中的case设计的。
func switchDemo5() {
s := "a"
switch {
case s == "a":
fmt.Println("a")
fallthrough
case s == "b":
fmt.Println("b")
case s == "c":
fmt.Println("c")
default:
fmt.Println("...")
}
}输出：
a
bgo module导入本地包
1、在同一个项目下
注意：在一个项目（project）下我们是可以定义多个包（package）的。
（1）目录结构
现在的情况是，我们在moduledemo/main.go中调用了mypackage这个包。
moduledemo
├── go.mod
├── main.go
└── mypackage
└── mypackage.go（2）导入包
这个时候，我们需要在moduledemo/go.mod(通过 go mod init生成)中按如下定义：
module moduledemo
go 1.14然后在moduledemo/main.go中按如下方式导入mypackage
package main
import (
"fmt"
"moduledemo/mypackage" // 导入同一项目下的mypackage包
)
func main() {
mypackage.New()
fmt.Println("main")
}（3）案例
实现方式：（同包下直接调用即可）
1、先把.go文件放在相应的package下
2、然后手动import所需要的模块所在的package
3、最后，在调用相应的方法时通过 package_Name.func_Name()的形式来完成调用(这里注意，能被其他模块调用的函数其Name的首字符一定要大写！！也就是在 Go 中，公共函数以大写字母开始，私有函数以小写字母开头)
2、不同项目下
（1）目录结构
├── moduledemo
│ ├── go.mod
│ └── main.go
└── mypackage
├── go.mod
└── mypackage.go（2）导入包
这个时候，mypackage也需要进行module初始化，即拥有一个属于自己的go.mod文件，内容如下：
module mypackage
go 1.14然后我们在moduledemo/main.go中按如下方式导入：
import (
"fmt"
"mypackage"
)
func main() {
mypackage.New()
fmt.Println("main")
}因为这两个包不在同一个项目路径下，你想要导入本地包，并且这些包也没有发布到远程的github或其他代码仓库地址。这个时候我们就需要在go.mod文件中使用replace指令。
在调用方也就是moduledemo/go.mod中按如下方式指定使用相对路径来寻找mypackage这个包。
module moduledemo
go 1.14
require "mypackage" v0.0.0
replace "mypackage" => "../mypackage"（3）举个例子
最后我们再举个例子巩固下上面的内容。
我们现在有文件目录结构如下：
├── p1
│ ├── go.mod
│ └── main.go
└── p2
├── go.mod
└── p2.gop1/main.go中想要导入p2.go中定义的函数。
p2/go.mod内容如下：
module liwenzhou.com/q1mi/p2
go 1.14p1/main.go中按如下方式导入
import (
"fmt"
"liwenzhou.com/q1mi/p2"
)
func main() {
p2.New()
fmt.Println("main")
}因为我并没有把liwenzhou.com/q1mi/p2这个包上传到liwenzhou.com这个网站，我们只是想导入本地的包，这个时候就需要用到replace这个指令了。
p1/go.mod内容如下：
module github.com/q1mi/p1
go 1.14
require "liwenzhou.com/q1mi/p2" v0.0.0
replace "liwenzhou.com/q1mi/p2" => "../p2"此时，我们就可以正常编译p1这个项目了。
