Golang go语言速成手册与细节分析（基础篇）
适合有其它编程语言经验（最好是C）的同学，快速上手go语言的相关特性，了解go语言的运行细节，并结合许多实用的go伪代码来服务于真实场景。
go语言速成手册与细节分析
-
-
- GO语言简介
-
- 诞生原因
- 特点
- 天然支持高并发
- 语法规范
-
- go命令
- 语法规范
- 标识符命名规则
- 导出名(共有私有)
- 数据类型与变量
-
- 数据类型
-
- 整型类型
- 浮点数类型
- 字符串类型
- 基本数据类型转换
- 基本数据类型与string转换
- 值类型和引用类型
- 变量
-
- 零值
- 多变量声明
- 短变量声明
- 作用域
- 运算符
-
- 算术运算符
-
- 除法
- 取模
- 自增、自减
- 关系运算符
- 逻辑运算符
-
- 短路与、短路或
- 赋值运算符
- 指针
- 结构
-
- 返回值
-
- 多值返回
- if
-
- 语法细节
- if 语句定义的变量作用域在if内
- 执行细节
- for
-
- 执行流程
- for 包含 while
-
- while/do-while
- 死循环
- 使用细节
- switch
-
- 语法细节
- 高级用法
- break、continue、goto、return
-
- break
-
- 使用label控制跳出层数
- continue
- goto
- return
- 包
-
- 包的作用
- 包名与引入
- 默认项目结构
- 函数
-
- 内存分区与形参实参
- 递归调用
- init函数
- 匿名函数
-
- 使用方式
- 全局匿名函数
- 闭包
-
- demo分析
- defer
-
- 一个值defer
- 多个值defer
- 函数参数的传递方式
- 常用系统函数
-
- 字符串函数
- 日期和时间函数
- 内置函数（buildin）
- 异常处理
-
-
- 自定义错误
-
- 数组和切片
-
- 数组
-
- 初始化数组的方式
- 遍历
- 二维数组
-
- 遍历
- 切片
-
- 使用方式
- 遍历
- 拷贝
- string和slice
- map（映射）
-
- key
- value
- 增删查改
- 遍历
- 切片
- 排序
-
GO语言简介
诞生原因
- 目前编程语言不能合理的利用多核CPU
- 软件系统复杂度越来越高，缺乏简洁高效。主要问题：
1.风格不统一
2.对硬件的调度，运行速度不够
3.处理大并发不够好
- C/C++运行速度够快，但是编译速度慢，存在内存泄漏等问题需要解决。
特点
静态编译语言的安全和性能+动态语言开发维护的高效率
- 从C中继承表达式语法，控制结构，基础数据结构，调用参数传值，保留C一样的编译执行方式及弱化的指针。
- 引入包机制，每个.go必须属于一个包
- 垃圾回收，内存自动回收
天然支持高并发
（1）语法层面支持并发，实现简单
（2）goroutine，轻量级线程，可实现大并发处理，高效利用多核
（3）线程间管道通信机制
（4）函数返回多个值
（5）CPS（communicating sequential process）并发模型
（6）切片slice，延时执行defer
语法规范
- 保持语法和代码风格高度规范
go命令
- gofmt main.go # 直接shell输出，自动修正缩进代码
参数：-w 输出重定向至文件
语法规范
- 2 + 4 * 5 //运算符两侧加空格
- 大括号唯一写法
func main(){
} // 正确
func main()
{
} // 错误
- 每行超过80字符，使用","换行
- 编译时，每行自动添加;
- 没有用的包等语法默认必须强制删除，否则无法通过编译。
标识符命名规则
（1）英文大小写，_，0-9
（2）不能数字开头
（3）严格区分大小写
（4）不包含空格
（5）_，空标识符，仅作为占位符，本身的值会被忽略
（6）不能系统关键字
- 驼峰法: stuName xxxYyyZzz
导出名(共有私有)
在 Go 中，如果一个名字以大写字母开头，那么它就是已导出**（共有）**的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。若首字母小写（私有）只能本包中使用。
pizza 和 pi 并未以大写字母开头，所以它们是未导出的。
在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。
执行代码，观察错误输出。
然后将 math.pi 改名为 math.Pi 再试着执行一次。
package main
import (
"fmt"
"math"
) //注意是()
func main() {
fmt.Println(math.Pi)
}
数据类型与变量
数据类型
整型类型
- 默认的int，uint长度与运行的操作系统有关。
- 转义符 T% 显示类型，unsafe.Sizeof()显示长度
- go中的 nil = null
浮点数类型
- 存放方式，浮点数=符号+指数+尾数
- 浮点数都是有符号的
- 浮点数长度固定，不受操作系统影响
- .512, 5.12, 5.1234e2
字符串类型
- go中没有专门的字符类型，储存单个字符（英文byte，中文rune）。
- go的字符串由一个字节为一个单位，对比C是由一个字符为单位。（英文一个字符一个字节，中文一个字符两个字节）
- 字符串赋值后无法任何改变。
- 双引号识别转义字符，反引号以原生形式输出（输出源代码、防止攻击）。
- “+”拼接字符串（长字符串换行“+”留在上一行，原因自动;）。
基本数据类型转换
不同数据类型任何情况不能自动转换（低精度到高精度等），必须使用强制转换（显式转换）。
- 强制转换语法
var int32_i int32 = 100
var int64_i int64 = int64(i) //变量i转换为int
1.转换后int32_i还是int32，只是把转换后的值赋予int64_i。
2.高精度->低精度(int64->byte)，会溢出处理。
-
int32 + 10 为int32不能赋值到int64
var n1 int64 = 100 var n2 int32 = 100 n1 = n2 + 10 //n2 + 10为int32不能直接赋值int64，编译不通过 n1 = int64(n2) + 10 //编译通过 -
var n1 int32 = 12 var n2 int8 = 0 n2 = (int8)n1 + 128 //编译不通过，128不是int8 n2 = (int8)n1 + 127 //编译通过，但是溢出处理
基本数据类型与string转换
- 基本->string
(1)fmt.Sprintf
str = fmt.Sprintf("%d" , num_int)
(2)strconv
#strconv.Itoa int快速转为str
#FormatInt
strconv.FormatInt(int64(original_int64_varialble), radix)
#第一个输入必须int64，第二个为转换的进制2-36
#FormatFloat
#FormatBool
- string->基本， strconv
#strconv.ParseBool
b , _ = strconv.ParseBool(str)
#多返回值：bool与err，不需要的_忽略接收
#strconv.ParseInt
默认返回值数据类型为int64，需要其他int类型需要强制转换。
- 逻辑转换错误
#若string为“hello",强制转换成int，则转换失败默认赋值为默认值0。
值类型和引用类型
- 值类型：基本数据类型int，float、bool、string、arrauy、struct。
#变量直接储存值，内存通常分配在栈。（编译器逃逸分析可能分配在堆）
- 引用类型：指针、slice切片、map、管道chan、接口interface。
#变量储存地址，这个地址对应的空间才是存储的值，内存通常在堆上分配，当没有变量引用这个地址时，变成垃圾被GC回收。
变量
零值
没有明确初始值的变量声明会被赋予它们的 零值。
零值是：
数值（整型、浮点型）类型为 0，
布尔类型为 false，
字符串为 ""（空字符串）。
多变量声明
1.var n1, n2, n3 int
2.var n, name, n3 = 1 , “tom”， 2
3.n, name, n3 := 1 , “tom”， 2 //类型推导
短变量声明
func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java)
}
函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用
//全局变量
var{
n1 = 1
name = "tom"
n2 = 3
}
作用域
- 函数内部声明的变量为局部变量，作用域仅限于函数内部
- 函数外部声明的变量为全局变量在整个包都有效，如果首字母大写，可以在整个程序import后跨包使用
- 如果在if/for代码块中声明，仅在该代码块有效
运算符
- go语言不支持三元运算符
算术运算符
除法
- 运算结果保留，根据运算的数据类型中高精度的决定：
10 / 4 = 2 //运算的两个数都是整型，因此转换为整形，数据溢出，结果为2
var i float = 10 / 4 //还是2
var i float = 10.0 / 4 //2.5，需要浮点数参与运算
取模
- a % b = a - a / b * b //a / b需要向下取整到整型
自增、自减
a := b++ //错误，只能单独b++使用
if i++ > 0 { //错误
-
强制语法统一，独立使用i++，减少歧义
-
无–i，++i
关系运算符
- 只返回bool值
逻辑运算符
- 返回bool值
短路与、短路或
- && 也叫短路与，如果第一个为false，则第二个条件的代码不会运行判断，最终结果为false。
- || 也叫短路或，如果第一个条件为true，则第二个条件不会判断，最终结果为true。
赋值运算符
-
从右向左运算
-
=, +=, -=, *=, /=, %=
-
<<=, >>=, &=, ^=, |=,
<<= // c = c << 2 , 右移两位后赋值c
&= // c = c & 2 , 与2位与后赋值c
指针
-
**区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。**移动指针需要使用unsafe包
-
变量名不等于数组开始指针，如果p2array为指向数组的指针， *p2array不等于p2array[0]。
-
数组做参数时, 需要被检查长度。
结构
返回值
多值返回
1.只接受多值返回中的部分值
// 使用_进行占位
a, _, c = fun_return_abc()
2.两种返回方式
//
func swap(x, y string) (string, string) {
return y, x
}
//
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
if
语法细节
- 就算逻辑块内只有一条语句也必须有大括号。
if a > 0 {
fmt.Println("a")
}
- if判断条件建议不带()
- else，else if必须不换行
if ... {
...
} else if{
...
} else {
...
}
if 语句定义的变量作用域在if内
同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。
- 该语句声明的变量作用域仅在
if逻辑块之内。 - 同时在if语句判断条件中只能写判断，不能赋值等操作。
执行细节
- 多分支控制只有一个出口，即多个if条件满足，对第一个为真的执行，执行完跳出条件判断。
if 条件1 { // 1为真
...
} else if 条件2 { // 2为真
...
} else if 条件3 {
...
} else {
...
}
//执行完1后跳出条件判断
package main
// 推荐的引入包的方式
import (
"fmt"
"math"
)
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
} else { //必须else不换行，保证这种格式
fmt.Printf("%g >= %g\n", v, lim)
}
// 这里开始就不能使用 v 了
return lim
}
func main() {
// 由内层开始执行，先pow最后println
fmt.Println(
pow(3, 2, 10),
pow(3, 3, 20),
)
}
for
执行流程
1.循环变量初始化 i++
2.执行循环条件 i <= 10
3.判断条件（返回bool值）；若为真，执行循环操作（语句块1）
4.执行循环变量迭代
5.反复1234，知道循环条件False
for i := 1 ; i <= 10 ；i++ {
语句块1
}
for 包含 while
while/do-while
func main() {
sum := 1
for sum < 1000 {
sum += sum
}
fmt.Println(sum)
}
for {
if 循环条件表达式{ //决定dowhile还是while
break
}
循环操作
循环变量迭代
}
死循环
如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。
- 搭配break设置跳出条件
使用细节
- 循环调节返回值一定为bool
- 可以只跟判断条件
for i < 10 {
i++
}
- 数组、字符串遍历
- 下标
for i := 0; i < len(str); i++ {
fmt.Println(str[i])
}
- 注意下标遍历字符串：go中全部按照utf8编码，字符串格式按照一个字节为单位划分，中文为三个字符串，因此需要str转rune再遍历。
str = []rune(str)
- for range方式
- 默认转换为rune，按照字符遍历，不需要转换
for index, val := range str {
fmt.Println(val)
}
switch
语法细节
- 无break
switch 表达式 {
case 表达式1, 表达式2, ...:
语句块1
case 表达式3, 表达式4, ...:
语句块2
default:
语句块
}
-
switch、case后可以跟常量、变量、函数的返回值
-
case后的数据类型必须和switch后的数据类型严格统一、完全一致
-
case后可以跟多个表达式
case 5, 10, n1 :
语句块
-
若case后为常量（只要是变量就可以），则不同的case后的常量之间不能数值重复
-
default语句块不是必备的
高级用法
- 无条件的switch，使多重判断更简洁（类似if else的逻辑）
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning!")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}
//在switch内声明变量，不推荐
func main() {
switch t := time.Now() {
case t.Hour() < 12:
fmt.Println("Good morning!")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}
- fallthrough 穿透特性
如果在case语句后增加fallthrough，则会继续判断下一个case
case a:
语句块1
fallthrough //会判断下面的case
case b:
语句块2
- type switch
判断interface变量中实际指向的变量类型
break、continue、goto、return
break
- 中断for，跳出switch
使用label控制跳出层数
label1: {
label2: {
label3: {
break label1 // 若没有标签默认跳出一层，也就是跳出label3这一层，跳出最近的一层for
// label1 等于break break break
}
}
}
- 标签名字随意，格式固定。
continue
- 结束本次循环，继续执行下一次循环；也可以使用label来确定是跳过那一层循环
goto
- 无条件的转移到程序指定的行，通常与条件语句配合使用，实现条件转移，跳出循环等功能。
- 一般主张不使用goto
return
- 跳出所在的方法或函数。
包
- 一个包=一个文件夹，本质创建不同的文件夹来存放不同的程序文件
- go的每一个文件都属于一个包，通过包的形式来管理文件和项目目录结构
- package、import
包的作用
- 区分同名函数、变量等标识符
- 当程序文件多时，构建合理的项目结构
- 作用域，控制函数、变量等访问范围
包名与引入
-
通常与当前.go上一级文件目录名称保持一致，一般为小写字母
-
首字母大写（可以是变量名、函数名）为可导出（公有、可导出、跨包使用），小写（私有、不可导出）
-
注意区分包名和包所在上级目录文件夹名称
//被调用文件，在/.../dir下
package utils //1.utils为包名，package规定打包的包名 2.package第一行
//调用文件
package use_utils
import (
"/.../dir" //在dir路径下寻找包
)
utils.TestFun() //用包名调用函数
- import默认路径从环境变量$GOPATH下的src开始，编译器自动从src寻找引入
- 包名过长可以使用别名（原包名不可继续使用）
import (
utils "/.../dir" //命名包别名为utils，后续引用**只能**使用别名，不能用原包名
)
-
同一包下不能有相同的函数名（以包做命名空间）
-
一个包也就是一个文件夹下可以有多个.go文件，但是都属于一个包，因此不能有相同的函数名和全局变量名
-
如果需要编译成一个可执行文件，则需要将这个包声明为main包，其它的库文件名称可以自定义
go build -o \bin\test.exe（保存路径） \...\main(需要编译的项目目录)
- 引入的包必须使用，不使用如下：
import (
"a"
_ "b" //引入不使用
)
默认项目结构
- src存放源码
- package存放，编译后的库文件（类似.dll，.so）
函数
func 函数名 (形参列表) (返回值列表) {
执行语句
return 返回值列表
}
-
函数中的变量是局部的，函数外不生效
-
基本数据类型和数组都是值传递，即值拷贝。在函数内修改，不会影响到原来的值。（不同的物理地址，可能变量名相同）
-
引用类型传递，传递的是被引用值的地址或者索引，因此修改的是同一个物理地址（指针），但是地址本身还是值传递
-
严格不允许函数名称重名（不支持函数重载）
-
在go中函数也是一种数据类型，可以赋值给一个变量，则该变量是一个函数类型变量，通过此变量可以调用函数
func myFun(funvar func(int, int) int, num1 int, num2 int) { //funvar是函数变量形参名字
return funvar(num1, num2)
}
- 为了简化数据类型定义，go支持自定义数据类型（与typedef很类似，别名）;一般在程序import后就type，在函数中局部生效
type mySum func(int, int)int //mySum等价于func(int, int)int函数数据类型
//注意在虽然本质都是同一种类型，但是编译器认为两个是两种数据类型
- 函数返回值命名
//主要作用是返回时按照函数返回值列表顺序接收
func test(n1 int, n2 int) (n3 int, n4 int){
n3 = n1
n4 = n2
return //直接return，按照
}
n3, n4 = test(1,2)
- 使用"_"作为占位符，忽略返回值
- 支持可变参数（动态参数个数）；如果有可参数需要将可变参数放在形参列表最后
//支持0到多个参数
func sum(arg... int) sum int { //arg为标识符，可以是其它名称
}
//支持1到多个参数
func sum(n1 int, arg... int) sum int {
}
//求一个到多个int的和
func sum(n1 int, vars_int... int) int {
sum := n1
for i :=0; i < len(vars_int); i++ {
sum += var[i]
}
return sum
}
内存分区与形参实参
-
栈区（通常存放基本数据类型）、堆区（通常存放引用数据类型）、代码区（存放代码）、全局区、常量区…（go编译器存在逃逸分析机制）
-
栈区函数结束释放，堆区当这个引用类型没有任何变量引用这个地址被GC回收
-
运行一次函数在栈区中拥有一个命名空间（下面的demo适用于栈区的基本基本数据类型）
func test (n1 int) { //使用栈区中test栈区中的n1来接收
n1 = n1 + 1
fmt.Println(n1) //输出11
}
func main {
n1 := 10 //在栈区中的main栈区创建n1
test(n1) //main栈区n1对test栈区n1赋值，实参对形参赋值
fmt.Println(n1) //调用完毕，回收test栈区，输出10
}
栈区 ------ test栈区
|
--- main栈区
|
--- ...
递归调用
- 每一次调用都会为test生成一个新的栈，最后逐层回收
- 局部变量相互独立，只是名字相同
func test(n int) {
if n > 2 {
n--
test(n)
}
fmt.Println("n=" , n)
}
//输出 2 2 3
func test(n int) {
if n > 2 {
n--
test(n)
}else{
fmt.Println("n=" , n)
}
}
//输出 2
init函数
-
每一个源文件都可以包含一个init函数，该函数会在main函数执行前，被go运行框架调用。
-
文件有全局变量定义：变量定义->init->main
-
init主要作用：完成初始化工作
-
引入的包有init时完整执行顺序：
package main //1
import ( //2
"/.../utils"
)
func init() { //6
}
func main() { //7
}
package utils //3
func init() { //4
}
func main() { //5
}
匿名函数
- 如果我们某个函数只希望使用一次，可以考虑匿名函数，匿名函数也可以多次调用
使用方式
- 定义匿名函数时直接调用（只能调用一次，使用较多）
func main() {
res1 := func (n1 int, n2 int) int {
return n1 + n2
}(10, 20)
}
- 将匿名函数赋值给一个变量，再通过变量调用匿名函数（可以多次使用，使用频率低，意义：可以在函数内定义函数）
func main() {
func_name := func (n1 int, n2 int) int {
return n1 + n2
}
res1 := func_name*(10, 20)
}
全局匿名函数
- 将函数赋值给全局变量，则可以在整个程序中通过全局变量调用函数
闭包
- 闭包就是一个函数和与其有关的引用环境组合的一个整体（本质是一个函数）
- 闭包=函数返回函数+函数内被使用的变量
// 累加器
func AddUpper() func (int) int {
// 闭包开始
var n int = 10
return func (x int) int { 返回的是一个匿名函数，但是函数引用了函数外的n，因此匿名函数和n形成了一个整体，构成了闭包
n = n + x
return n
}
// 闭包结束
}
func main() {
f := AddUpper()
fmt.Println(f(1)) // 10 + 1 = 11
fmt.Println(f(2)) // 11 + 2 = 13
fmt.Println(f(3)) // 13 + 3 = 16
}
// 返回的数据类型是fun(int)int
// 关键是返回的函数使用到了那些变量，函数和它使用的变量构成闭包
demo分析
- 闭包的优势：向函数传递一次参数，参数可以被持久化记录，不用每次调用都反复传入参数；当函数的部分参数需要短暂持久化（但是需要有接口可以修改），使用闭包
// 需求：1.判断文件名是否有.后缀，若有返回直接文件名（直接返回name.xxx），若无加上.xxx返回(name.xxx)
2..xxx可以修改即可
3.被调用的时候，大部分时间后缀使用.jpg
func MakeSuffix (suffix string) func (string) string {
return func (name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
} else {
return name
}
}
}
f := MakeSuffix(".jpg")
f("1") //返回1.jpg
f("2.jpg") //返回2.jpg
//闭包 = 匿名函数 + suffix
defer
- 需要创建资源（数据库连接、文件句柄、锁等），但是需要在函数执行完毕后及时释放资源 ，因此提供defer（延时机制）
一个值defer
defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
package main
import "fmt"
func main() {
//当执行到defer语句时，会语句将压入defer栈（独立栈）
//**当函数执行完毕后，按照先入后出的方式出栈执行**
defer fmt.Println("!") //3
defer fmt.Println("world") //2
fmt.Println("hello,") //1
}
func main() {
n1 := 1
n2 := 2
// 在defer语句入栈时，会将相关的**值拷贝**（和原变量为两个独立的变量）同时入栈
defer fmt.Println(n1) //1
defer fmt.Println(n2) //2
n1++
n2++
fmt.Println(n1+n2) //5
}
func test() {
file = openfile()
defer file.close() //不用考虑具体啥时候关闭文件句柄
...
}
多个值defer
package main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 10; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
函数参数的传递方式
值类型默认使用值传递，引用类型默认使用引用传递
如果希望函数外修改函数内变量，只能引用传递，利用&以指针的方式操作变量
- 值传递
地址1 地址2
| -> |
值1 值2
拷贝效率低
值类型：基本数据类型int、float、bool、string，数组，结构体
- 引用传递
地址1 -> 地址2
| |
值1 值1
拷贝效率高
引用类型：指针、切片、map、管道chan、interface等
常用系统函数
buildin，内建函数不用import直接使用
字符串函数
-
len(str)，按字节统计字符串长度或数组长度（go使用utf8，ascii字符（字母和数字）占一个字节，一个汉字（或者其它语言）占用三个字节）
-
中文字符串遍历，r := []rune(str)
-
字符串转整形，n, err := strconv.Atoi("")，可以利用err判断输入是否是纯数字；整数转字符串，str = strconv.Itoa()，不存在不能转换
-
字符串转byte，转为ascii，var bytes = []byte(“str”)；byte转字符串（ascii），str = string([]byte{97, 98, 99})
-
10进制转2、8、16进制，str = strconv.FormatInt(123, 2)
-
查找子串是否在指定字符串，strings.Contains(“abcddd”, “abc”) // true
-
统计字符串由几个指定的子串，strings.Count(“abcddd”, “ddd”) // 3
-
不区分大小写比对字符串，strings.EqualFold(“str”, “str”)；不区分大小写，str == str
-
返回子串第一次出现的index，若无返回-1，strings.Index(“adcddd”, “ddd”) // 3；返回子串最后一次出现的index，若无返回-1，strings.LastIndex(“adcddd”, “ddd”)
-
使用子串替换另一个子串，n为第n个，n=-1表示全部替换，strings.Replace(“abcddd”, “ddd”, “eee”, n)，可以是变量传入
-
按照指定字符拆分字符串，strings.Split(“1,2,3,4”, “,”)，返回一个字符串数组
-
大小写转换，全部变为大写或小写，strings.ToLower(str)，strings.ToUpper(str)
-
去掉字符串两边的所有空格，strings.TrimSpace(" test ")
-
将字符串左右两边指定的字符去掉，不考虑去除去字符串的顺序，strings.Trim("!ahelloa!", “!”) // hello
-
将字符串左（右）侧指定字符去掉，不考虑去除去字符串的顺序，strings.TrimLeft("!hello!", “!”)、strings.TrimRight("!hello!", “!”)
-
是否以指定的字符串开头、结尾，strings.HasPrefix(“abc”, “a”)、strings.HasSuffix(“abc”, “c”)
日期和时间函数
内置函数（buildin）
异常处理
-
go追求简洁优雅，不支持try…catch.finally
-
go引入的异常处理方式：defer、panic、recover
-
go抛出一个panic异常 -> 在defer中的recover中捕获这个异常 -> 处理异常
func test() {
defer func () {
err := recover() // 捕获异常，将异常返回err变量（error类型）保存
... // 处理异常
}() // 匿名函数，无输入，无输出
... // 此处抛出错误
... // 跳过错误，抛出异常后继续执行
}
func test() {
defer func () {
if err := recover() ; err != nil { // 捕获 + 判断
...
} // 捕获异常，将异常返回err变量（error类型）保存
... // 处理异常
}() // 匿名函数，无输入，无输出
... // 此处抛出错误
... // 跳过错误，抛出异常后继续执行
}
自定义错误
- errors.New(“错误说明”)创建自定义错误，返回error类型的值
- panic，接受一个interface{}类型的值（可以是任何 值）作为参数，接收error，输出error信息，退出程序
// 读取配置文件，目录下有无指定文件名文件
func readConf(name string) (err error) {
if name == "config.ini" {
return nil
} else {
return errors.New("file name error!")
}
}
func test() {
err := readConf("...")
if err != nil {
panic(err)
}
...
}
数组和切片
数组
-
在go中数组时值类型，arrayName为变量名（a），数组为变量数据（1）。（var a int = 1）
-
创建数组后自动为每个数组元素赋零值（详情见零值章节）
-
arrayName地址为数组首地址（=第一个元素的地址），arrayName是值类型，直接存放数组（数组看做一个和int等一样的值）；数组地址为：首地址（变量arrayName地址、第一个元素地址）+ n * 数组类型长度（例如：int64，为8个字节，地址加8）
-
数组时多个相同数据类型的数据的组合，数组一旦声明，其长度就固定，不能动态变化。（数组长度也是数组信息的一部分）
-
注意切片和数组的区别，var arr []int 这种写法arr是切片
-
数组可以是基本数据类型也可以是引用类型，但是只能全部元素是一种数据类型
-
数组下标从0开始
-
go数组属于值类型，在默认情况下进行值传递，因此进行值拷贝不会影响原数组
-
想函数外修改函数，需要传递指针，使用引用传递
初始化数组的方式
- 定义数组：var arrayName [n]float64；访问、赋值数组元素；arrayName [0] = …
- 使用顺序：开辟空间->赋值->访问
var array [3]int = [3]int{1, 2, 3}
var array = [3]int{1, 2, 3}
var array = [...]int{1, 2, 3} // ...系统自动判断大小
var array = [...]int{1: 2, 0: 1, 2: 3} // 数组下标+数据
array := [...]int{1, 2, 3} // 类型推导，最简洁
遍历
- 常规遍历
for i := 0; i < len(array); i++ {
...
}
- for-range遍历
for index, value := range array {
...
}
// 1. 第一个返回值index是数组下标
// 2. 第二个value是在该下标位置的值
// 3. index、value都是在for内部可见的局部变量
// 4. 若遍历数组时不需要index或value，使用_替代
// 5. index和value是两个变量接受返回值，名称不固定，习惯使用index和value
二维数组
var arr [n1][n2]int //n1，n2为数组真实大小，不是从0开始
arr[n3][n4] = i //n3,n4为索引从0开始计数
&arr[0][0] //第一个一维数组首地址
&arr[1][0] //第二个一维数组首地址
var arr [n][n]int = [...][n]int{{...},{...}} // 只有一维数组也就是第一个位置可以...，因为是按照初始化时的个数来自动确定个数
var arr = [n][n]int{{...},{...}}
- 底层寻址方式和一维数组一致，数组元素变为数组指针；也就是二维数组保存着n个一维数组的首地址，然后通过一维数组的首地址访问一维数学组。
遍历
for i := 0; i < len(arr); i++ {
for j := 0; j < len(arr[i]); j++ { // 注意len(arr[i])
...
}
}
for i1, v1 := range arr {
for i2, v2 := range v1 { // 注意range v1
}
}
切片
-
切片是数组的引用（修改slice，原数组也会改变），切片的长度可以变化，是一个动态的数组。（底层追加的方式是1.有容量的概念存在一定的冗余；若冗余不足，2.拷贝原切片指向的数组的值到一个新的空间，然后创建切片返回新的切片，然后通过切片变量接收）
-
数组a[1]（有确定大小），切片a[]（无确定大小）
-
与数组相比，遍历、访问元素（silce[n]）、len()用法相同
-
定义：var sliceName []int
-
切片有容量的概念（容量可以动态变化），也就是目前能存放最大元素的个数，使用cap()函数可以查看；一般容量是元素个数的两倍
-
切片本质是一个结构体：1.首个元素的首地址 2.长度 3.容量\
-
切片必须定义后，赋值后再使用
-
切片可以引用切片（或其它引用变量）
-
在初始化时不能越界，但是可以动态增长。可以使用append函数动态追加元素
-
append、copy的所有对象只能是切片，不能是数组
slice3 = append(silce3, 400, 500, 600) // append的方式是创建一个新的切片（数组），然后返回切片通过赋值传递给切片
slice3 = append(slice3, slice1...) // 切片追加切片
使用方式
- 定义一个切片，通过引用的方式去引用已经创建好的数组；数组已经创建，再创建切片使切片引用数组
- 简写：arr[0:end]，arr[:end]；arr[start:len(arr)]， arr[:end]；arr[0:len(arr)]，arr[:]
var array [3]int = [3]int{1, 2, 3}
silceName := array[0:2] // 引用array数组起始下标为0，终止下标为2**（不包含2）**
- 通过make函数（还可以创建映射和通道）创建切片，此时切片还是结构体，指向一个数组空间（但是数组匿名无法通过数组名访问），只能通过切片访问。数据结构模型不变：切片（结构体）->数组空间（数组匿名或数组名可访问）
- make创建切片的同时创建一个数组（空间），数组底层由切片维护，数组无法通过数组的正常方式访问
var slice_name []type = make([]type, len, cap(可以忽略))
var slice []int = make([]int, 4, 8)
slice[0] = 100
- 直接定义
var silce_name []int = []int{1, 2, 3}
遍历
- for循环常规遍历
for i := 0; i < len(slice); i++ {
...
}
- for-range
for i, v := range slice {
... //i为index，v为value
}
拷贝
-
拷贝和被拷贝的两个数据空间是独立的
-
copy(slice1, slice2) // slice1内容拷贝到slice2，若容量1>2优先数组下标0开始，剩下的不拷贝；2>1从数组下标0开始拷贝，2多余剩下的内容不变
string和slice
- string也是一个结构体：1.数组首地址、2.长度，底层指向一个byte数组；因此string可以使用切片操作，slice也指向byte数组
// 数组截取
str := "hello,world!"
str_slice := str[7:] // world!
- 使用slice修改字符串，
// 错误
str[0] = 'z' // str本质是字符串结构体，无法通过数组的方式直接寻址，修改字符串
// 将string->[]byte/[]rune（byte或rune切片），然后修改
arr1 := []byte(str)
/*
1.如果处理中文需要转为[]rune
2.原因：go中string为byte数组（以字节为单位），go使用utf-8，ascii内的字符（英文、数字等）一个字节，其他语言（中文等）三个字节，因此要使用rune
*/
arr1[0] = 'z'
map（映射）
- key-value
- var mapName map[keytype]valuetype；var name map[int]string
- 声明后（未分配内存，数组会直接分配内存，赋零值），再make（分配内存），再使用，可以动态调整大小
//
var mapName map[int]string
mapName = make(map[int]string, 10)
//
var mapName = make(map[int]string, 10)
// 底层自动make
var mapName map[int]string = map[int]string{1:"no1", 2:"no2", } // 注意,
mapName := map[int]string{
1:"no1",
2:"no2", // 注意,
}
- key唯一，如果出现重复的key赋值，会覆盖同名的key-value，同时无序
- key-value在map中存放是无序的（与key大小、添加顺序无关），可能每次输出的顺序都不一样
- len(map)，一个map有len(map)对键值对
- map是引用类型的数据，传递时函数外可修改
- map自动扩容（动态增长），不会报错；切片必须手动append扩容，否则panic错误
- map的value是结构体最好，可以管理复杂的数据
key
- key的数据类型可以是：bool、数字、string、channel，还可以是以上几个类型的接口、结构体、数组
- 不能是：slice、map、function，因为无法用==判断
- 通常是：int、string
value
- 通常为数字、string、map、struct
- 嵌套map，value为map
// 一个学生信息包含：name、sex、address
//为最外层map分配空间
studentMap := make(map[int]map[string]string) // 不输入大小默认为1
// 为具体的学生分配空间
studentMap[1] = make(map[string]string, 3)
studentMap[1]["name"] = "..."
studentMap[1]["sex"] = "..."
studentMap[1]["address"] = "..."
增删查改
- 增、改
map["key"] = value // 如果key还没有就增加，如果已经存在就更新（也就是修改）
- 删除
delete(map, "key") // 如果key不存在，不会报错，也不会操作
// 如果全部删除所有的key，推荐2
// 1. 遍历key
// 2. map=make()，make一个新的同名map，让原来的成为垃圾被gc回收
- 查找
val, res := map[“1”] // val储存返回键值，res返回是否存在键值，true存在，false不存在
遍历
- 只能使用for-range遍历
for k, v := range map {
...
}
切片
- 数组元素是map的动态数组
var mapSlice []map[int]string // 定义map切片
mapSlice = make([]map[int]string, 2) // 为slice分配内存
mapSlice[0] = make(map[int]string, 2) // 为map元素分配内存
// 在slice中追加map
newMap ：= map[int]string {
...
}
mapSlice = append(mapSlice, newMap)
排序
-
key排序，key无序，每次输出可能顺序都不一样
-
排序思路，先将map的key放入切片，对切片排序，遍历切片，按照key输出map
var keys []int
for k, _ := range map {
keys = append(keys, k) //遍历插入key切片
}
sort.Ints(keys) // 使用自带方法排序
for _, k := range keys {
map[keys] //按照key的顺序遍历输出
}