关键词：
文件操作
文件是数据源(保存数据的地方)的一种，比如经常使用的word文档，txt文档，excel文件...都是文件。文件最主要的作用就是保存数据，它即可以保存一张图片，也可以保持视频，声音...
输入流和输出流
文件在程序中是以流的形式来操作的
流：数据在数据源(文件)和程序(内存)之间经历的路径
输入流：数据从数据源(文件)到程序(内存)的路径
输出流：数据从程序(内存)到数据源(文件)的路径
os.File封装所有文件相关操作，File是一个结构体
? 后面操作文件，会经常使用到os.File结构体
打开文件和关闭文件
使用的函数和方法
案例演示
import (
"fmt"
"os"
)
func main()
//打开文件
//概念说明：file的叫法
//1. file 叫 file对象
//2. file 叫 file指针
//3. file 叫 file文件句柄
file, err := os.Open("e:/test.txt")
if err != nil
fmt.Println("Open file err = ", err)
//输出文件，看看文件是什么，看出file就是一个指针 *Filr
fmt.Printf("file = %v", file) //file = &0xc000070780
//关闭
err = file.Close()
if err != nil
fmt.Println("Close file err = ", err)
读文件操作应用案例
- 读取文件的内容并显示在终端(带缓冲区的方式)，使用os.Open，file.Close，bufio.NewReader()，reader.ReadString函数和方法
import (
"bufio"
"fmt"
"io"
"os"
)
func main()
//打开文件
//概念说明：file的叫法
//1. file 叫 file对象
//2. file 叫 file指针
//3. file 叫 file文件句柄
file, err := os.Open("E:/gostudent/src/2020-04-02/utils/utils.go")
if err != nil
fmt.Println("Open file err = ", err)
//当函数退出时，要及时的关闭file
defer file.Close() //要及时关闭file句柄，否则会有内存泄漏
//创建一个*Reader ， 是带缓冲的
/*
const (
defaultBufSize = 4096 //默认的缓冲区为4096
)
*/
reader := bufio.NewReader(file)
//循环读取文件的内容
for
str, err := reader.ReadString(‘
‘) //读到一个换行就结束
if err == io.EOF //io.EOF 表示文件的末尾
break
//输出内容
fmt.Print(str)
fmt.Println("文件读取结束...")
- 读取文件的内容并显示在终端(使用ioutil一次将整个文件读入到内存中)，这种方式适用于文件不大的情况。相关方法和函数ioutil.ReadFile
import (
"fmt"
"io/ioutil"
)
func main()
//使用ioutil.ReadFile一次性将文件读取到位
file := "E:/gostudent/src/2020-04-02/utils/utils.go"
content, err := ioutil.ReadFile(file)
if err != nil
fmt.Printf("read file err = %v", err)
//把读取到的内容显示到终端
//fmt.Printf("%v", content) //[]byte
fmt.Printf("%v", string(content)) // []byte
//这里没有显示的Open文件，因此也不需要显示的Close文件
//因为，文件的Open和Close被封装到ReadFile函数内部
写文件操作应用案例
os.OpenFile函数
- 创建一个新文件，写入内容：5句 “Hello,zisefeizhu”
import (
"bufio"
"fmt"
"os"
)
func main()
filePath := "E:/gostudent/src/2020-04-05/abc.txt"
file, err := os.OpenFile(filePath, os.O_CREATE | os.O_WRONLY, 0666)
if err != nil
fmt.Printf("open file err = %v
", err)
return
//及时关闭file句柄
defer file.Close()
//准备写入5句: "hello,zisefeizhu"
str := "hello,zisefeizhu
" //
表示换行
//写入时，使用带缓存的*Writer
writer := bufio.NewWriter(file)
for i := 0; i< 5; i++
writer.WriteString(str)
//因为write是带缓存的，因此在调用WriterString方法时
//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中，否则文件中会没有数据!!!
writer.Flush()
- 打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好，紫色飞猪”
import (
"bufio"
"fmt"
"os"
)
func main()
//2)打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好，紫色飞猪”
//1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
filePath := "E:/gostudent/src/2020-04-05/abc.txt"
file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, 0666)
if err != nil
fmt.Printf("open file err = %v
", err)
return
//及时关闭file句柄
defer file.Close()
//准备写入10句: "hello,zisefeizhu"
str := "你好，紫色飞猪!
" //
表示换行
//写入时，使用带缓存的*Writer
writer := bufio.NewWriter(file)
for i := 0; i< 10; i++
writer.WriteString(str)
//因为write是带缓存的，因此在调用WriterString方法时
//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中，否则文件中会没有数据!!!
writer.Flush()
- 打开一个存在的文件，在原来的内容追加内容“你好，jingxing”
import (
"bufio"
"fmt"
"os"
)
func main()
//1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
filePath := "E:/gostudent/src/2020-04-05/abc.txt"
file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, 0666)
if err != nil
fmt.Printf("open file err = %v
", err)
return
//及时关闭file句柄
defer file.Close()
//追加内容
str := "你好，jingxing
" //
表示换行
//写入时，使用带缓存的*Writer
writer := bufio.NewWriter(file)
for i := 0; i< 10; i++
writer.WriteString(str)
//因为write是带缓存的，因此在调用WriterString方法时
//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中，否则文件中会没有数据!!!
writer.Flush()
- 打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句“你好，深圳”
import (
"bufio"
"fmt"
"io"
"os"
)
func main()
//1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
filePath := "E:/gostudent/src/2020-04-05/abc.txt"
file, err := os.OpenFile(filePath, os.O_RDWR | os.O_APPEND, 0666)
if err != nil
fmt.Printf("open file err = %v
", err)
return
//及时关闭file句柄
defer file.Close()
//先读取原来文件的内容，并显示在终端
reader := bufio.NewReader(file)
for
str, err := reader.ReadString(‘
‘)
if err == io.EOF //如果读取到文件的末尾
break
//显示到终端
fmt.Print(str)
//追加内容
str := "你好，深圳
" //
表示换行
//写入时，使用带缓存的*Writer
writer := bufio.NewWriter(file)
for i := 0; i< 5; i++
writer.WriteString(str)
//因为write是带缓存的，因此在调用WriterString方法时
//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中，否则文件中会没有数据!!!
writer.Flush()
5）编写一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了
说明：使用ioutil.ReadFile / ioutil.WriteFile完成写文件的任务
import (
"fmt"
"io/ioutil"
)
func main()
//将e:/abc.txt 文件内容导入到e:/abc.txt
//1. 首先将 e:/abc.txt 内容读取到内存
//2. 将读取到的内容写入d:/abc.txt
file1Path := "E:/gostudent/src/2020-04-05/abc.txt"
file2Path := "D:/abc.txt"
data, err := ioutil.ReadFile(file1Path)
if err != nil
//说明读取文件有错误
fmt.Printf("read file err = %v
", err)
return
err = ioutil.WriteFile(file2Path, data, 0666)
if err != nil
fmt.Printf("write file error = %v
", err)
判断文件是否存在
Go判断文件或文件夹是否存在的方法为使用os.Stat()函数对返回的错误值进行判断：
-
如果返回的错误为nil，说明文件或文件夹存在
-
如果返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
-
如果返回的错误为其它类型，则不确定是否存在
文件编程应用实例
拷贝文件
说明：将一张图片/电影/mp3拷贝到另一个文件e:/abc.jpg
func Copy(dst Writer,src Reader)(written int64, err error)
注意：Copy函数是io 包提供的
import (
"bufio"
"fmt"
"io"
"os"
)
//编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(srcFileName string, dstFileName string) (written int64, err error)
srcFile, err := os.Open(srcFileName)
if err != nil
fmt.Printf("open file err = %v
", err)
defer srcFile.Close()
//通过srcfile，获取到Reader
reader := bufio.NewReader(srcFile)
//打开dstFileName
dstFile,err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
if err != nil
fmt.Printf("open file err = %v
", err)
return
//通过dstFile，获取到Writer
writer := bufio.NewWriter(dstFile)
defer dstFile.Close()
return io.Copy(writer, reader)
func main()
//将d:/abc.jpg 文件拷贝到e:/abc.jpg
//调用CopyFile 完成文件拷贝
srcFile := "d:/abc.jpeg"
dstFile := "e:/abc.jpg"
_, err := CopyFile(srcFile, dstFile)
if err == nil
fmt.Printf("拷贝完成
")
else
fmt.Printf("拷贝错误 err = %v
", err)
统计英文、数字、空格和其它字符数量
import (
"bufio"
"fmt"
"io"
"os"
)
//定义一个结构体，用于保存统计结果
type CharCount struct
ChCount int //记录英文个数
NumCount int //记录数字的个数
SpaceCount int //记录空格的个数
OtherCount int //记录其它字符的个数
func main()
//思路：打开一个文件，创一个Reader
//每读取一行，就去统计该行有多少个英文、数字、空格和其它字符
//然后将结果保存到一个结构体
fileName := "E:/gostudent/src/2020-04-05/abc.txt"
file,err := os.Open(fileName)
if err != nil
fmt.Printf("open file err = %v
", err)
return
defer file.Close()
//定义个CharCount实例
var count CharCount
//创建一个Reader
reader := bufio.NewReader(file)
//开始循环读取fleName的内容
for
str, err := reader.ReadString(‘
‘)
if err == io.EOF //读到文件末尾就退出
break
//为了兼容中文字符，可以将str转成[]rune
strChange := []rune(str)
//遍历str，进行统计
for _,v := range strChange
switch
case v >= ‘a‘ && v <= ‘z‘ :
fallthrough //穿透
case v >= ‘A‘ && v <= ‘Z‘ :
count.ChCount++
case v == ‘ ‘ || v == ‘ ‘ :
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)
命令行参数
希望能够获取到命令行输入的各种参数，该如何处理？
os.Args是一个string的切片，用来存储所有的命令行参数
举例说明
import (
"fmt"
"os"
)
func main()
fmt.Println("命令行的参数有：", len(os.Args))
//遍历os.Args切片，就可以得到所有的命令行输入参数值
for i, v := range os.Args
fmt.Printf("args[%v] = %v
", i ,v)
//E:gostudentsrc2020-04-05>go run main.go 999
//命令行的参数有： 2
//args[0] = C:UserslxxxxnAppDataLocalTempgo-build133979866001exemain.
//exe
//args[1] = 999
flag包用来解析命令行参数
说明：前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命令行
比如:cmd>main.exe -f c:/aaa.txtx -p 200 -u root 这样形式的命令行，go设计者给提供了flag包，可以方便的解析命令行参数，而且参数顺序可以随意
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,"port",3306,"端口号，默认为3306")
//有一个非常重要的操作转换，必须调用该方法
flag.Parse()
//输出结果
fmt.Printf("user = %v pwd = %v host = %v port = %v",
user, pwd, host, port)
//E:gostudentsrc2020-04-05>go run main.go -u root -pwd zisefeizhu -h 20.0.0.201 -port 3306
//user = root pwd = zisefeizhu host = 20.0.0.201 port = 3306
Json
Json基本介绍
Json(JavaScript Object Notation)是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。key - val
Json是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式
Json易于机器解析和生成，并有效地提升网络传输效率，通常程序在网络传输时会先将数据(结构体、map等)序列化成json字符串，到接收方得到json字符串时，在反序列化恢复成原来的数据类型(结构体、map等)。这种方式已然成为各个语言的标准
应用场景
Json数据格式说明
在JS语言中，一切都是对象。因此，任何数据类型都可以通过JSON来表示，例如字符串、数字、对象、数组、map、结构体等
JSON键值对是用来保存数据的一种方式
键/值对组合中的键名写在前面并用双引号“”包裹，使用冒号：分隔，然后紧接值：
["key1":val1,"key2":val2,"key3":val3,"key4":[val4,val5],
"key1":val1,"key2":val2,"key3":val3,"key4":[val4,val5]]
比如
"firstName":"Json"
"name":"tom","age":18,"address":["北京","上海"]
["name":"zisefeizhu","age":18,"address":["北京","上海"],
"name":"jingxing","age":18,"address":["北京","上海"]]
Jsnon数据在线解析
https://www.json.cn/ 网站可以验证一个json格式的数据是否正确。尤其是在编写比较复杂的json格式数据时，很有用
Json的序列化
json序列化是指，将有key - value 结构的数据类型(比如结构体、map、切片)系列化成json字符串的操作
应用案例
演示一下结构体、map和切片的序列化，其它数据类型的序列化类似
import (
"encoding/json"
"fmt"
)
//定义一个结构体
type Monster struct
Name string
Age int
Bithday string
Sal float64
Skill string
func testStruct()
//演示
monster := Monster
Name : "牛魔王",
Age : 500,
Bithday : "2001-11-11",
Sal : 8000.0,
Skill : "牛头拳",
//将monster 序列化
data, err := json.Marshal(&monster)
if err != nil
fmt.Printf("序列号错误 err = %v
", err)
//输出序列化后的结果
fmt.Printf("monster 序列化后 = %v
", string(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.Printf("序列号错误 err = %v
", err)
//输出序列化后的结果
fmt.Printf("monster 序列化后 = %v
", string(data))
//演示对切片进行序列化，这个切片[]map[string]interface
func testSlice()
var slice []map[string]interface
var m1 map[string]interface
//使用map前，需要先make
m1 = make(map[string]interface)
m1["name"] = "jack"
m1["age"] = "7"
m1["address"] = "北京"
slice = append(slice, m1)
var m2 map[string]interface
//使用map前，需要先make
m2 = make(map[string]interface)
m2["name"] = "tom"
m2["age"] = "20"
m2["address"] = [2]string"墨西哥","夏威夷"
slice = append(slice, m2)
//将切片进行序列化操作
data, err := json.Marshal(slice)
if err != nil
fmt.Printf("序列号错误 err = %v
", err)
//输出序列化后的结果
fmt.Printf("monster 序列化后 = %v
", string(data))
//对基本数据类型序列化，意义不大
func testFloat64()
var num1 float64 = 2345.67
//对num1进行序列化
data, err := json.Marshal(num1)
if err != nil
fmt.Printf("序列号错误 err = %v
", err)
//输出序列化后的结果
fmt.Printf("monster 序列化后 = %v
", string(data))
func main()
//演示将结构体、map、切片进行序列化
testStruct()
testMap()
testSlice()
testFloat64()
//输出
// monster 序列化后 = "Name":"牛魔王","Age":500,"Bithday":"2001-11-11","Sal":8000,"Skill":"牛头拳"
//monster 序列化后 = "address":"洪崖洞","age":30,"name":"红孩儿"
//monster 序列化后 = ["address":"北京","age":"7","name":"jack","address":["墨西哥","夏威夷"],"age":"20","name":"tom"]
//monster 序列化后 = 2345.67
注意事项
对于结构体的序列化，如果希望序列化后的key的名字可以重新制定，那么可以给struct制定一个tag标签
import (
"encoding/json"
"fmt"
)
//定义一个结构体
type Monster struct
Name string `json:"monster_name"` //反射机制 //:两边不要分开
Age int `json:"monster_age"`
Bithday string
Sal float64
Skill string
func testStruct()
//演示
monster := Monster
Name : "牛魔王",
Age : 500,
Bithday : "2001-11-11",
Sal : 8000.0,
Skill : "牛头拳",
//将monster 序列化
data, err := json.Marshal(&monster)
if err != nil
fmt.Printf("序列号错误 err = %v
", err)
//输出序列化后的结果
fmt.Printf("monster 序列化后 = %v
", string(data))
func main()
//演示将结构体、map、切片进行序列化
testStruct()
//输出
// monster 序列化后 = "monster_name":"牛魔王","monster_age":500,"Bithday":"2001-11-11","Sal":8000,"Skill":"牛头拳"
Json的反序列化
json反序列化是指，将json字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作
应用案例
演示一下将json字符串反序列化成结构体、map和切片
import (
"encoding/json"
"fmt"
)
//定义一个结构体
type Monster struct
Name string
Age int
Birthday string
Sal float64
Skill string
//演示将json字符串，反序列化成struct
func unmarshalStruct()
//说明str在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
str := ""Name":"牛魔王","Age":500,"Birthday":"2001-11-11","Sal":8000,"Skill":"牛头拳""
//定义一个Monster 实例
var monster Monster
err := json.Unmarshal([]byte(str), &monster)
if err != nil
fmt.Printf("unmarshal err = %v
", err)
fmt.Printf("反序列化后 monster = %v monster.Name = %v
", monster, monster.Name)
//演示将json字符串，反序列化成map
func unmarshalMap()
str := ""address":"洪崖洞","age":30,"name":"红孩儿""
//定义一个map
var a map[string]interface
//反序列化
//注意：反序列化map,不需要make，因为make操作被封装到Unmarshal函数
err := json.Unmarshal([]byte(str), &a)
if err != nil
fmt.Printf("unmarshal err = %v
", err)
fmt.Printf("反序列化后 a = %v
",a)
//演示将json字符串，反序列化成切片1
func unmarshalSlice()
str := "["address":"北京","age":"7","name":"jack","+
""address":["墨西哥","夏威夷"],"age":"20","name":"tom"]"
//定义一个slice
var slice []map[string]interface
//反序列化，不需要make，因为make操作被封装到Unmarshal函数
err := json.Unmarshal([]byte(str), &slice)
if err != nil
fmt.Printf("unmarshal err = %v
", err)
fmt.Printf("反序列化后 slice = %v
", slice)
func main()
unmarshalStruct()
unmarshalMap()
unmarshalSlice()
//输出
//反序列化后 monster = 牛魔王 500 2001-11-11 8000 牛头拳 monster.Name = 牛魔王
//反序列化后 a = map[address:洪崖洞 age:30 name:红孩儿]
//反序列化后 slice = [map[address:北京 age:7 name:jack] map[address:[墨西哥 夏威夷] age:20 name:tom]]
注意事项
? 1) 在反序列化一个json字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致
? 2) 如果json字符串是通过程序获取到的，则不需要再对“”转义处理
单元测试
先看一个需求
在工作中，会遇到这样的情况，就是去确认一个函数，或者一个模块的结果是否正确
如：
func addUpper(n int) int
res := 0
for i := 1; i <= n; i++
res += i
return res
传统的方法
在main函数中，调用addUpper函数，看看实际输出的结果是否和预期的结果一致，如果一致，则说明函数正确，否则函数有错误，然后修改错误
//一个被测试函数
func addUpper(n int) int
res := 0
for i := 1; i <= n - 1; i++
res += i
return res
func main()
//传统的测试方法，就是在main函数中使用看看结果是否正确
res := addUpper(10)
if res != 55
fmt.Printf("addUpper错误 返回值 = %v 期望值 = %v
", res, 55)
else
fmt.Printf("addUpper正确 返回值 = %v 期望值 = %v
", res, 55)
//addUpper错误 返回值 = 45 期望值 = 55
传统方法的缺点分析
-
不方便，需要在main函数中去调用，这样就需要去修改main函数，如果现在项目正在运行，就可能去停止项目
-
不利于管理，因为当我们测试多个函数或者多个模块时，都需要写在main函数，不利于我们管理和清晰我们思路
-
引出单元测试。 -> testing测试框架 可以解决问题
单元测试
基本介绍
Go语言中自带有一个轻量级的测试框架testing和自带的go test命令来实现单元测试和性能测试，testing框架和其它语言中的测试框架类似，可以基于这个框架写针对相应函数的测试用例，也可以基于该框架写相应的压力测试用来。通过单元测试，可以解决如下问题：
-
确保每个函数是可运行，并且运行结果是正确的
-
确保写出来的代码性能是好的
-
单元测试能及时的发现程序设计或实现的逻辑错误，使问题及早暴露，便于问题的定位解决，而性能测试的重点在于发现程序设计上的一些问题，让程序能够在高并发的情况下还能保持稳定
快速入门
使用Go的单元测试，对addUpper和sub函数进行测试
特别说明：测试时，可能需要暂时退出360(因为360可能会认为生成的测试用例程序是木马)
演示如何进行单元测试
单元测试的运行原理示意图
单元测试快速入门总结
-
测试用例文件名必须以 _test.go结尾。比如cal_test.go，cal不是固定的
-
测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名，比如TestAddUpper
-
TestAddUpper(t *testing.T)的形参类型必须是 *testing.T
-
一个测试用例文件中，可以有多个测试用例韩式，比如TestAddUpper，TestSub
-
运行测试用例指令
(1) cmd>go test [如果运行正确，无日志，错误时，会输出日志]
(2) cmd>go test -v [运行正确或是错误，都输出日志]
-
当出现错误时，可以使用t.Fatalf来格式化输出错误信息，并退出程序
-
t.Logf方法可以输出相应的日志
-
测试用例函数，并没有放在main函数中，也可以执行，这就是测试用例的方便之处
-
PASS表示测试用例运行成功，FALL表示测试用例运行失败
-
测试单个文件，一定要带上被测试的源文件
? go test -v cal_test.go cal.go
- 测试单个方法
? go test -v -test.run TestAddUpper
综合案例
单元测试综合案例要求：
-
编写一个Monster结构体，字段Name、Age、Skill
-
给Monster绑定方法Store，可以将一个Monster变量(对象)，序列化后保存到文件中
-
给Monster绑定方法ReStore，可以将一个序列化的Monster，从文件中读取，并反序列化为Monster对象，检查反序列化，名字正确
-
编程测试用例文件store_test.go,编写测试用例函数TestStore和TestRestore进行测试
代码区
monster/monster.go
package monster
import (
"encoding/json"
"io/ioutil"
"fmt"
)
type Monster struct
Name string
Age int
Skill string
//给Monster绑定方法Store，可以将一个Monster变量(对象)，序列化后保存到文件中
func (this *Monster) Store() bool
//先序列化
data, err := json.Marshal(this)
if err != nil
fmt.Println("marshal err =", err)
return false
//保存到文件
filePath := "e:/monster.ser"
err = ioutil.WriteFile(filePath, data, 0666)
if err != nil
fmt.Println("write file err =",err)
return false
return true
//给Monster绑定方法ReStore，可以将一个序列化的Monster从文件中读取，
//并反序列化为Monster对象，检查反序列化，名字正确
func (this *Monster) ReStore() bool
//1. 先从文件中，读取序列化的字符串
filePath := "e:/monster.ser"
data, err := ioutil.ReadFile(filePath)
if err != nil
fmt.Println("ReadFile err =", err)
return false
//2. 使用读取到data []byte，对反序列化
err = json.Unmarshal(data, this)
if err != nil
fmt.Println("UnMarshal err = ", err)
return false
return true
monster/monster_test.go
package monster
import "testing"
//测试用例，测试Store方法
func TestStore(t *testing.T)
//先创建一个Monster实例
monster := &Monster
Name: "红孩儿",
Age: 10,
Skill: "吐火",
res := monster.Store()
if !res
t.Fatalf("monster.Store() 错误，希望为 = %v 实例为 = %v",true,res)
t.Logf("monster.Store() 测试成功！")
func TestReStore(t *testing.T)
//测试数据是很多，测试很多次，才确定函数，模块..
//先创建一个Monster实例，不需要制定字段的值
var monster = &Monster
res := monster.ReStore()
if !res
t.Fatalf("monster.ReStore() 错误，希望为 = %v 实例为 = %v",true,res)
//进一步判断
if monster.Name != "红孩儿"
t.Fatalf("monster.ReStore() 错误，希望为 = %v 实例为 = %v","红孩儿",monster.Name)
t.Logf("monster.ReStore() 测试成功！")
go36-23,24,25-单元测试(代码片段)
...测试、灰度测试等。这里主要针对单元测试进行讲解。Go语言是一门很重视程序测试的语言，它不但自带了testing包，还有专门用于程序测试的命令gotest。要想真正用好一个工具，就需要了解它的核心逻辑。测试源码文件单元测试... 查看详情
4.4go语言中的单元测试(代码片段)
基本概念上一节提到，代码完成的标准之一还包含了单元测试，这部分也是很多开发流程中不规范的地方。写过单元测试的开发人员应该理解，单元测试最核心的价值是为了证明：为什么我写的代码是正确的？... 查看详情
4go语言单元测试性能测试与监控(代码片段)
4、Go语言单元测试、性能测试与监控1、单元测试1.1单元测试简介1.2testing的使用1.3案例1.4测试中一些函数的区别2、代码覆盖率3、断言库4、BDD测试框架5、基准测试5.1基准测试简介5.2基准测试案例6、性能监控7、常见的调优参数1、... 查看详情
4go语言单元测试性能测试与监控(代码片段)
4、Go语言单元测试、性能测试与监控1、单元测试1.1单元测试简介1.2testing的使用1.3案例1.4测试中一些函数的区别2、代码覆盖率3、断言库4、BDD测试框架5、基准测试5.1基准测试简介5.2基准测试案例6、性能监控7、常见的调优参数1、... 查看详情
go单元测试从0到1(代码片段)
文章目录1.什么是单元测试2.单元测试的作用3.Go如何写单元测试4.gotest命令参数5.快速生成单测代码6.看看单元测试覆盖率7.使用单测框架写单测8.小结参考文献1.什么是单元测试单元测试（unittesting），是指对软件中的... 查看详情
go单元测试从0到1(代码片段)
文章目录1.什么是单元测试2.单元测试的作用3.Go如何写单元测试4.gotest命令参数5.快速生成单测代码6.看看单元测试覆盖率7.使用单测框架写单测8.小结参考文献1.什么是单元测试单元测试（unittesting），是指对软件中的... 查看详情
都9102年了，还不会docker？10分钟带你从入门操作到实战上手(代码片段)
...个可移植的容器中，并且该容器可以运行在几乎所有linux系统中（Windows10目前也原生支持，Win10前需要内置虚拟机），正所谓“一次打包，到处运行”。Docker容器的运行是完全的沙箱机制，相互之间不会有任何关联（除非自己串... 查看详情
go+单元测试教程（4.20）(代码片段)
...结合Go之心，让工程师处理数据不需要学习新的开发语言，让初学者学习编程、开发作品的门槛更低的编程语言。正文单元测试是编写符合规范的Go+程序的重要组成部分。测试包提供了编写单元测试所需的工具，使... 查看详情
go语言学习笔记—基础—go工具（5.1）：单元测试——测试和验证代码的框架(代码片段)
...元进行检查和验证。对于单元测试中单元的含义，如C语言中指一个函数，Java中指一个类，图形化软件中指一个窗口或菜单等。总的来说，单元是认为规定的最小可测试功能模块，单元测试是在软件开发过程中... 查看详情
6.3利用go语言接口进行mock单元测试(代码片段)
单元测试重点是对代码逻辑进行测试，也就是证明：为什么你的代码是正确的。Mock测试是单元测试中常用的一种手段，特别是对于代码运行时对环境有严重依赖的，可以在不具备相应环境的情况下运行。例如：数据库、中间件... 查看详情
go-单元测试详解与代码(代码片段)
目录概述Go的单元测试基础知识快速入门进阶单个文件的测试单个函数的测试单元测试覆盖率参考概述常言道，不会测试的程序猿不是好的产品经理！！！现在越来越多测试和运维的工作也需要研发来做了，本... 查看详情
go程序开发快速入门(代码片段)
...量名和注释，确保代码易于理解和维护。2、错误处理：Go语言有很好的错误处理机制，应该合理地处理错误，以便于排除错误。3、内存管理：Go语言自动管理内存，但是如果存在大量的内存分配和垃圾回收，会影响程序性能，因... 查看详情
一文带你进行go语言工程实践(代码片段)
文章目录并发和Goroutine并发和并行的区别线程与协程的区别Goroutine用法并发的通信Channel并发安全依赖管理GOPATHGOPATH弊端GoVendorGoVendor弊端GoModule（最终解决方案依赖管理三要素配置文件版本规则杂项中心仓库管理依赖库依赖的... 查看详情
14.go语言编译与工具(代码片段)
Go语言编译与工具Go语言的工具链非常丰富，从获取源码、编译、文档、测试、性能分析，到源码格式化、源码提示、重构工具等应有尽有。在Go语言中可以使用测试框架编写单元测试，使用统一的命令行即可测试及输出测试报告... 查看详情
go基础之单元测试反射网络编程操作redis操作mysql(代码片段)
...作5.2.2查询操作5.3Go实现MySQL事务5.4sqlx使用一、单元测试Go语言中自带有一个轻量级的测试框架testing和自带的gotest命令来实现单元测试和性能测试。我们执行gotest命令时，它会遍历该go包中所有以_test.go结尾的测试文件，然... 查看详情
c语言数组(数组取值操作|array[i][j]用法等价于*(*(array=i)+j)用法|下标操作到指针操作演化过程)(代码片段)
文章目录一、数组取值操作方法二、一维数组取值下标操作到指针操作演化过程三、二维数组取值下标操作到指针操作演化过程一、数组取值操作方法给定一个二维数组:intarray[2][3];取第iii行,第jjj列的数据,可以使用array[i][j]方式,... 查看详情
gotest(代码片段)
这篇文章主要介绍下在Go语言中如何做单元测试和基准测试。gotest工具Go语言中的测试依赖gotest命令。编写测试代码和编写普通的Go代码过程是类似的，并不需要学习新的语法、规则或工具。gotest命令是一个按照一定约定和组织的... 查看详情
linux系统之部署go语言开发运行环境(代码片段)
Linux系统之部署Go语言开发运行环境一、Go语言介绍1.Go语言简介2.Go语言的撰写风格二、本地环境检查1.检查系统版本2.检查系统内核版本三、yum直接安装go1.检查yum仓库2.安装go3.创建环境变量四、二进制安装Go1.安装wget等工具2.下载G... 查看详情