【Golang第10章：文件操作】GO语言的文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析
介绍
这个是在B站上看边看视频边做的笔记，这一章是Glang的文件操作
主要内容有Go语言文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析，GO语言如何设置命令行参数
配套视频自己去B站里面搜【go语言】，最高的播放量就是
里面的注释我写的可能不太对，欢迎大佬们指出╰(°▽°)╯
文章目录
- 介绍
- (十)、文件操作
-
- 一、文件的基本介绍
- 二、打开文件和关闭文件
- 三、读文件操作
- 四、写文件操作
-
- 1.基本介绍 `os.OpenFile` 函数
- 2.基本应用实例-方式一
- 3.基本应用实例-方式二
- 五、判断文件是否存在
- 六、拷贝文件
- 七、统计字符数量
- 八、命令行参数
-
- 1.基本介绍
- 2.举例说明
- 3.flag 包用来解析命令行参数
- 九、JSON文件
-
- 1.基本介绍
- 2. json 数据格式说明
- 3. json 数据在线解析
- 4. json 的序列化
- 5. json 的反序列化
- 章节目录
(十)、文件操作
一、文件的基本介绍
-
文件的概念
文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的word 文档,txt 文件,excel 文件…都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声音…
-
输入流和输出流
-
os.File 封装所有文件相关操作，File 是一个结构体
总结：后面我们操作文件，会经常使用到os.File 结构体.
二、打开文件和关闭文件
-
使用的函数和方法
-
案例
package main import ( "fmt" "os" ) func main() { //概念说明: file 的叫法 //1.file 叫file对象 //2.flle 叫file指针 //3.file叫file文件句柄 //打开文件 file, err := os.Open("d:/test.txt") //当前没有test.txt 文件 if err != nil { fmt.Println("open file err=", err) //输出open file err= open d:/test.txt: The system cannot find the file specified. } //输出下文件，看看，文件是什么 ，重下面看出文件就是一个指针 fmt.Printf("file=%v\n", file) //无文件输出 file=，有文件file=&{0xc0000da780} //关闭文件 err = file.Close() if err != nil { fmt.Println(err) } }
三、读文件操作
- 读取文件的内容并显示在终端(带缓冲区的方式)，使用
os.Open,file.Close,bufio.NewReader(),reader.ReadString函数和方法.
代码
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
//打开文件
file, err := os.Open("d:/test.txt") //当前没有test.txt 文件
if err != nil { //输出错误
fmt.Println("open file err=", err) //输出open file err= open d:/test.txt: The system cannot find the file specified.
}
//当函数退出时，要及时关闭file
defer file.Close() //要及时关闭file句柄，否则会有内存泄漏.
//创建一个 *Reader ,是带缓冲的 ,默认大小为4096
reader := bufio.NewReader(file)
//循环的读取文件的内容
for {
//reader会返回2个结果str为具体内容，err为错误信息
str, err := reader.ReadString('\n') //使用带缓冲区，读到一个换行就结束
if err == io.EOF { //io.EOF表示文件的末尾
break //读到末尾后退出循环
}
//输出内容
fmt.Print(str) //因为默认有换行符，所以不需要Println进行换行
}
fmt.Println("-----文件读取结束-----")
}
- 读取文件的内容并显示在终端(使用
ioutil一次将整个文件读入到内存中)，这种方式适用于文件不大的情况。相关方法和函数(ioutil.ReadFile)
代码
package main
import (
"fmt"
"io/ioutil"
)
func main() {
//使用ioutil.ReadFile一次性将文件读取到位
file := "d:/test.txt"
content, err := ioutil.ReadFile(file) //只适合文件不太大的情况使用
if err != nil {
fmt.Printf("red file err=%v\n", err)
}
//把读取道德内容显示到终端
fmt.Printf("%v\n", content) //输出的是byte切片,因此我们需要转换为string类型
fmt.Printf("%v\n", string(content)) //或者fmt.Printf("%s\n", content)
//我们没有显示的Open文件，因此也不需要显示Close文件
//因为,文件的Open和close被封装到ReadFile函数内部
}
四、写文件操作
1.基本介绍 os.OpenFile 函数
const (
O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
O_RDWR int = syscall.O_RDWR // 读写模式打开文件
O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
O_CREATE int = syscall.O_CREAT // 如果不存在将创建一个新文件
O_EXCL int = syscall.O_EXCL // 和O_CREATE配合使用，文件必须不存在
O_SYNC int = syscall.O_SYNC // 打开文件用于同步I/O
O_TRUNC int = syscall.O_TRUNC // 如果可能，打开时清空文件
)
2.基本应用实例-方式一
-
创建一个新文件，写入内容5 句"hello, Gardon"
package main import ( "bufio" "fmt" "os" ) func main() { //创建一个新文件，写入内容5 句"hello, Gardon" //1.打开文件 d:/adc.txt filePath := "d:/adc.txt" //打开只写模式，并且，如果不存在将创建一个新文件，Linux权限为0666 file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666) if err != nil { fmt.Printf("打开文件错误：%v\n", err) return } //及时关闭file句柄 defer file.Close() //准备写入内容5 句"hello, Gardon" str := "hello, Gardon\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上 //写入时，使用带缓存的 *Writer writer := bufio.NewWriter(file) for i := 0; i < 5; i++ { writer.WriteString(str) //把str的内容循环5次写入缓存中 } //因为writer是带缓存，因此在调用Writerstring方法时，其实 //内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据 //真正写入到文件中,否则文件中会丢失数据 writer.Flush() //把缓存内容写入到实际文件中 } -
打开一个存在的文件中，将原来的内容覆盖成新的内容10 句"你好，世界!"
package main import ( "bufio" "fmt" "os" ) //打开一个存在的文件中，将原来的内容覆盖成新的内容10 句"你好，世界!" func main() { //1.打开文件 d:/adc.txt filePath := "d:/adc.txt" //打开只写模式，并且，把打开文件全部清除掉在写入，Linux权限为0666 file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0666) if err != nil { fmt.Printf("打开文件错误：%v\n", err) return } //及时关闭file句柄 defer file.Close() //准备写入内容5 句"hello, Gardon" str := "你好，世界！\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上 //写入时，使用带缓存的 *Writer writer := bufio.NewWriter(file) for i := 0; i < 10; i++ { writer.WriteString(str) //把str的内容循环5次写入缓存中 } //因为writer是带缓存，因此在调用Writerstring方法时，其实 //内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据 //真正写入到文件中,否则文件中会丢失数据 writer.Flush() //把缓存内容写入到实际文件中 } -
打开一个存在的文件，在原来的内容追加内容"ABC! ENGLISH!"
package main import ( "bufio" "fmt" "os" ) //打开一个存在的文件，在原来的内容追加内容"ABC! ENGLISH!" func main() { //1.打开文件 d:/adc.txt filePath := "d:/adc.txt" //打开只写模式，并且在原来的内容追加内容，Linux权限为0666 file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND, 0666) if err != nil { fmt.Printf("打开文件错误：%v\n", err) return } //及时关闭file句柄 defer file.Close() //准备追加内容" ABC! ENGLISH! " str := "ABC! ENGLISH!\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上 //写入时，使用带缓存的 *Writer writer := bufio.NewWriter(file) for i := 0; i < 10; i++ { writer.WriteString(str) //把str的内容循环10次写入缓存中 } //因为writer是带缓存，因此在调用Writerstring方法时，其实 //内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据 //真正写入到文件中,否则文件中会丢失数据 writer.Flush() //把缓存内容写入到实际文件中 } -
打开一个存在的文件，将原来的内容读出显示在终端，并且追加5 句"hello,你好，世界!"
package main import ( "bufio" "fmt" "io" "os" ) //打开一个存在的文件，将原来的内容读出显示在终端，并且追加5 句"hello,你好，世界!" func main() { //1.打开文件 d:/adc.txt filePath := "d:/adc.txt" //打开读写模式，并且在原来的内容追加内容，Linux权限为0666 file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0666) if err != nil { fmt.Printf("打开文件错误：%v\n", err) return } //及时关闭file句柄 defer file.Close() //函数执行完毕后关闭file句柄 //读取原先的内容，并显示在终端================== reader := bufio.NewReader(file) for { str, err := reader.ReadString('\n') if err == io.EOF { //如果读取到文件末尾，就break退出循环 break } //显示到终端 fmt.Print(str) } //============================================ //准备追加内容" hello,你好，世界! " str := "hello,你好，世界!\r\n" writer := bufio.NewWriter(file) for i := 0; i < 5; i++ { writer.WriteString(str) //把str的内容循环5次写入缓存中 } writer.Flush() }
3.基本应用实例-方式二
编程一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了.
说明：使用ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务.
代码：
package main
import (
"fmt"
"io/ioutil"
)
func main() {
//将D:/test.txt 文件导入到 D:/abc.txt 文件
//1.首先将D:/test.txt 内容读取到内存
//2.将读取道德内容写入 D:/abc.txt
file1Path := "D:/test.txt"
file2Path := "D:/abc.txt"
data, err := ioutil.ReadFile(file1Path) //读取文件，
if err != nil {
fmt.Println("文件读取错误,", err)
return //读取文件错误，直接结束整个函数
}
//写入文件，你要写入的路径，读取的路径，Linux权限
err = ioutil.WriteFile(file2Path, data, 0666)
if err != nil {
fmt.Println("文件写入错误,", err)
}
}
五、判断文件是否存在
golang判断文件或文件夹是否存在的方法为使用os. Stat()函数返回的错误值进行判断: .
- 如果返回的错误为nil,说明文件或文件夹存在
- 如果返回的错误类型使用
os.IsNotExist()判断为true,说明文件或文件夹不存在 - 如果返回的错误为其它类型，则不确定是否在存在
package main
import (
"fmt"
"os"
)
func PathExists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil { //文件或目录存在
return true, nil
}
//返回一个布尔值说明该错误是否表示一个文件或目录不存在。
//ErrNotExist和一些系统调用错误会使它返回真。
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
func main() {
filePath := "d:/abc1.txt"
exist, err := PathExists(filePath)
if exist {
fmt.Println("文件存在")
} else {
fmt.Println("文件不存在")
if err != nil {
fmt.Println(err)
}
}
}
六、拷贝文件
说明：将一张图片/电影/mp3 拷贝到另外一个文件
使用io 包func Copy(dst Writer, src Reader) (written int64, err error)
注意: Copy 函数是io 包提供的.
package main
import (
"bufio"
"fmt"
"io"
"os"
)
//将d盘下的test.txt拷贝到e盘下
//变量一个函数，接收2个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (writer int64, err error) {
srcFile, err := os.Open(srcFileName)
if err != nil {
fmt.Println("打开文件错误", err)
}
//通过srcfile，获取到 Reader
reader := bufio.NewReader(srcFile)
defer srcFile.Close() //完成函数后关闭srcFile
//打开dstFileName
dstFile1, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println("打开文件错误", err)
}
//通过writer1，获取到Writer
writer1 := bufio.NewWriter(dstFile1)
defer dstFile1.Close() //完成函数后关闭dstFile
return io.Copy(writer1, reader)
}
func main() {
//1.调用CopyFile完成文件拷贝
srcFile := "d:/test.txt"
dstFile := "e:/test.txt"
CopyFile(dstFile, srcFile)
_, err := CopyFile(dstFile, srcFile)
if err == nil {
fmt.Println("拷贝完成")
} else {
fmt.Println(err)
}
}
七、统计字符数量
**说明：**统计一个文件中含有的英文、数字、空格及其它字符数量
代码：
package main
import (
"bufio"
"fmt"
"io"
"os"
)
//统计一个文件中含有的英文、数字、空格及其它字符数量
//定义一个结构体，用户保存统计结果
type CharCount struct {
ChCount int //记录英文个数
NumCount int //记录数字的个数
SpaceCount int //记录空格的个数
OtherCount int //记录其它字符的个数
}
func main() {
//思路:打开一个文件，创一个Reader
//每读取一行，就去统计该行有多少个英文、数字、空格和其他字符
//然后将结果保存到一个结构体
fileName := "D:/test.txt"
file, err := os.Open(fileName)
if err != nil {
fmt.Println("打开文件失败，", err)
return
}
defer file.Close() //关闭file句柄，防止内存溢出
//定义CharCount实例
var count CharCount
//创建一个Reader
reader := bufio.NewReader(file)
for {
str, err := reader.ReadString('\n')
if err == io.EOF {
break
}
//遍历str,进行统计
for _, v := range str { //v拿到的是byte数组
switch {
case v >= 'a' && v <= 'z':
fallthrough //穿透处理，强制执行后面代码，fallthrough不能用在switch的最后一个分支。
case v >= 'A' && v <= 'Z':
count.ChCount++
case v == ' ' || v == '\t':
count.SpaceCount++
case v >= '0' && v <= '9':
count.NumCount++
default:
count.OtherCount++
}
}
}
fmt.Printf("字母的个数为%v 数字的个数为%v 空格的字符为%v 其他字符为%v",
count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}
八、命令行参数
我们希望能够获取到命令行输入的各种参数，该如何处理? 如图：=> 命令行参数
1.基本介绍
os.Args 是一个string 的切片，用来存储所有的命令行参数
2.举例说明
请编写一段代码，可以获取命令行各个参数
代码：
package main
import (
"fmt"
"os"
)
//获取命令行各个参数
func main() {
fmt.Println("命令行的参数有", len(os.Args))
//遍历os . Args切片，就可以得到所有的命令行输入参数值
for i, v := range os.Args {
fmt.Printf("args[%v]=%v\n", i, v)
}
}
go build -o test.exe .\main.go #打包
test.exe install ./config #例子
命令行的参数有 3
args[0]=D:\code\Go\src\demo2\05demo\main\test.exe # 启动程序
args[1]=install # 参数
args[2]=./config # 参数
3.flag 包用来解析命令行参数
说明: 前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命
令行。
比如：cmd>main.exe -f c:/aaa.txt -p 200 -u root 这样的形式命令行，go 设计者给我们提供了flag包，可以方便的解析命令行参数，而且参数顺序可以随意
请编写一段代码，可以获取命令行各个参数.
代码：
package main
import (
"flag"
"fmt"
)
func main() {
//定义几个变量，用于接收命令行的参数值
var user string
var pwd string
var host string
var port int
//&user 就是接收用户命令行中输入的-u 后面的是参数值
//"u" 就是 -u 指定参数
//"" 就是默认值
// "用户名默认为空" 返回的说明
flag.StringVar(&user, "u", "", "用户名默认为空")
flag.StringVar(&pwd, "pwd", "", "密码默认为空")
flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
flag.IntVar(&port, "p", 12345, "端口，默认为12345")
//这里有一个非常重要的操作，转换，调用该方法
flag.Parse()
//输出从控制台获取的结果
fmt.Printf("user=%v pwd=%v host=%v port=%v\n",
user, pwd, host, port)
}
go build -o test.exe .\main.go #打包
test.exe -u admin -pwd 123 -h 127.0.0.1 -p 3306 # 运行并接参数
user=admin pwd=123 host=127.0.0.1 port=3306 #输出
test.exe -u admin -pwd 123 -h 127.0.0.1 #使用默认值
user=admin pwd=123 host=127.0.0.1 port=12345
九、JSON文件
1.基本介绍
-
概述
JSON(avaScript Object Notation)是- -种轻量级的数据交换格式。易于人阅读和编写。同时也易
于机器解析和生成。key-valJSON是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式。
JSON易于机器解析和生成，并有效地提升网络传输效率,通常程序在网络传输时会先将数据(结构体、map等)序列化成json字符串到接收方得到json字符串时，在反序列化恢复成原来的数据类型(结构体、map等)。这种方式已然成为各个语言的标准。
序列化网络传输反序列化Golangjson字符串程序其他语言 -
应用场景(示意图)
2. json 数据格式说明
3. json 数据在线解析
https://www.json.cn/ 网站可以验证一个json 格式的数据是否正确。尤其是在我们编写比较复杂的
json 格式数据时，很有用。
[{"name":"tom","age":20,"address":["上海","北京"],"hobby":["足球","乒乓球"]},{"name":"mary","age":22,"address":["上海","北京","成都"]}]
格式化：
[
{
"name": "tom",
"age": 20,
"address": [
"上海",
"北京"
],
"hobby": [
"足球",
"乒乓球"
]
},
{
"name": "mary",
"age": 22,
"address": [
"上海",
"北京",
"成都"
]
}
]
4. json 的序列化
-
介绍
json 序列化是指，将有
key-value结构的数据类型(比如结构体、map、切片)序列化成json 字符串的操作。 -
案例
这里介绍一下
结构体、map和切片的序列化，其它数据类型的序列化类似。 -
代码
package main import ( "encoding/json" "fmt" ) //定义一个结构体======================== type Monster struct { Name string `json:"name"` //打标签，让json输出的是标签，使用的是反射机制 Age int `json:"age"` //打标签，让json输出的是标签，使用的是反射机制 Birthday string `json:"birthday"` //打标签，让json输出的是标签，使用的是反射机制 Sal float64 Skill string } func testStruct() { //演示 monster := Monster{ Name: "牛魔王", Age: 500, Birthday: "1263-01-25", Sal: 8000.0, Skill: "野蛮冲撞", } //结构体monster序列化 data, err := json.Marshal(&monster) if err != nil { fmt.Println("序列化错误，", err) } //输出序列化后的结果 fmt.Printf("\n结构体：序列化后的结果是:\n%v\n", string(data)) // fmt.Printf("方式2：序列化后的结果是:\n%s\n", data) } //============================================ //将map进行序列化============================== func testMap() { //定义一个map //var a map[string]interface{} //使用map,需要先make a := make(map[string]interface{}) a["name"] = "红孩儿" a["age"] = 30 a["address"] = "火焰山" //将a这个map进行序列化 data, err := json.Marshal(&a) if err != nil { fmt.Println("序列化错误，", err) } //输出序列化后的结果 fmt.Printf("\nmap：序列化后的结果是:\n%v\n", string(data)) // fmt.Printf("方式2：序列化后的结果是:\n%s\n", data) } //============================================ //对切片进行序列化 使用难一点的切片例如 []map[string]interface{} func testSlice() { var slice []map[string]interface{} m1 := make(map[string]interface{}) //声明并make m1["name"] = "孙悟空" m1["age"] = 500 m1["address"] = [2]string{"花果山", "水帘洞"} slice = append(slice, m1) //开辟空间并追加m1数组 m2 := make(map[string]interface{}) //声明并make m2["name"] = "杨戬" m2["age"] = 524 m2["address"] = "天庭" slice = append(slice, m2) //开辟空间并追加m2数组 //将切片进行序列化操作 data, err := json.Marshal(&slice) if err != nil { fmt.Println("序列化错误，", err) } //输出序列化后的结果 fmt.Printf("\n切片：序列化后的结果是:\n%v\n", string(data)) //fmt.Printf("方式2：序列化后的结果是:\n%s\n", data) } //============================================ //对基本数据类型序列化 ，对基本数据类型序列化意义不大 func testFloat64() { var num1 float64 = 2345.67 //对num1进行序列化 data, err := json.Marshal(&num1) if err != nil { fmt.Println("序列化错误，", err) } //输出序列化后的结果 fmt.Printf("\n基本数据：序列化后的结果是:\n%s\n", data) } //============================================ func main() { testStruct() testMap() testSlice() testFloat64() } -
注意事项
对于结构体的序列化，如果我们希望序列化后的key 的名字，由我们自己重新制定，那么可以给struct指定一个tag 标签.
//定义一个结构体======================== type Monster struct { Name string `json:"name"` //打标签，让json输出的是标签，使用的是反射机制 Age int `json:"age"` //打标签，让json输出的是标签，使用的是反射机制 Birthday string `json:"birthday"` //打标签，让json输出的是标签，使用的是反射机制 Sal float64 Skill string }
5. json 的反序列化
-
基本介绍
json 反序列化是指，将json 字符串反序列化成对应的数据类型(比如
结构体、map、切片)的操作 -
应用案例
这里介绍一下将json 字符串反序列化成
结构体、map和切片 -
案例
package main import ( "encoding/json" "fmt" ) type Monster struct { //用来获取json字符串的结构体 Name string `json:"name"` Age int `json:"age"` Birthday string `json:"birthday"` Sal float64 Skill string } //演示将json字符串，反序列化成struct func unmarshalStruct() { //模拟获取到json字符串 str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}" //定义一个monster实例 var monster Monster err := json.Unmarshal([]byte(str), &monster) //使用引用传递，才能改变monster if err != nil { fmt.Println("反序列化错误：", err) } //显示monster结构体数据 fmt.Println("结构体反序列化后：", monster) //{牛魔王 500 2011-11-11 8000 牛魔拳} } //反序列化成map func unmarshalMap() { str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}" //定义一个map //反序列化时，不需要make，因为make操作被封装到Unmarshal函数 var a map[string]interface{} //反序列化 err := json.Unmarshal([]byte(str), &a) //使用引用传递，才能改变monster if err != nil { fmt.Println("反序列化错误：", err) } fmt.Println("map反序列化后：", a) } //反序列化成切片 func unmarshalSlice() { //反序列化切片，需要完整的json字符串，获取的默认产数在前后添加[] str := "[{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}]" //定义一个切片 //反序列化时，不需要make，因为make操作被封装到Unmarshal函数 var slice []map[string]interface{} //反序列化 err := json.Unmarshal([]byte(str), &slice) //使用引用传递，才能改变monster if err != nil { fmt.Println("反序列化错误：", err) } fmt.Println("切片反序列化后：", slice) } func main() { unmarshalStruct() unmarshalMap() unmarshalSlice() } -
对上面代码的小结说明
-
在反序列化一个json 字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致。
-
如果json 字符串是通过程序获取到的，则不需要再对“ 转义处理。
-
章节目录
【Golang第1~3章：基础】如何安装golang、第一个GO程序、golang的基础
【Golang第4章：函数】Golang包的引用，return语句、指针、匿名函数、闭包、go函数参数传递方式，golang获取当前时间
【Golang第5章：数组与切片】golang如何使用数组、数组的遍历和、使用细节和内存中的布局；golang如何使用切片，切片在内存中的布局
【Golang第6章：排序和查找】golang怎么排序，golang的顺序查找和二分查找，go语言中顺序查找二分查找介绍和案例
【Golang第7章：map】go语言中map的基本介绍，golang中map的使用案例，go语言中map的增删改查操作，go语言对map的值进行排序
【Golang第8章：面向对象编程】Go语言的结构体是什么，怎么声明；Golang方法的调用和声明；go语言面向对象实例，go语言工厂模式；golang面向对象的三大特性：继承、封装、多态
【Golang第9章：项目练习】go项目练习家庭收支记账软件项目、go项目练习客户管理系统项目
【Golang第10章：文件操作】GO语言的文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析
【Golang第11章：单元测试】GO语言单元测试
【Golang第12章：goroutine协程与channel管道】GO语言goroutine协程和channel管道的基本介绍、goroutine协