go语言系统-从文件操作到单元测试
文件操作
文件是数据源(保存数据的地方)的一种,比如经常使用的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('\n') //读到一个换行就结束 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 \n", err) return } //及时关闭file句柄 defer file.close() //准备写入5句: "hello,zisefeizhu" str := "hello,zisefeizhu\n" // \n表示换行 //写入时,使用带缓存的*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 \n", err) return } //及时关闭file句柄 defer file.close() //准备写入10句: "hello,zisefeizhu" str := "你好,紫色飞猪!\n" // \n表示换行 //写入时,使用带缓存的*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 \n", err) return } //及时关闭file句柄 defer file.close() //追加内容 str := "你好,jingxing\n" // \n表示换行 //写入时,使用带缓存的*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 \n", err) return } //及时关闭file句柄 defer file.close() //先读取原来文件的内容,并显示在终端 reader := bufio.newreader(file) for { str, err := reader.readstring('\n') if err == io.eof { //如果读取到文件的末尾 break } //显示到终端 fmt.print(str) } //追加内容 str := "你好,深圳\n" // \n表示换行 //写入时,使用带缓存的*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\n", err) return } err = ioutil.writefile(file2path, data, 0666) if err != nil { fmt.printf("write file error = %v \n", 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\n", 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\n", 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("拷贝完成\n") } else { fmt.printf("拷贝错误 err = %v\n", 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 \n", err) return } defer file.close() //定义个charcount实例 var count charcount //创建一个reader reader := bufio.newreader(file) //开始循环读取flename的内容 for { str, err := reader.readstring('\n') 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 == '\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) }
命令行参数
希望能够获取到命令行输入的各种参数,该如何处理?
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 \n", i ,v) } } //e:\gostudent\src\2020-04-05>go run main.go 999 //命令行的参数有: 2 //args[0] = c:\users\lxxxxn\appdata\local\temp\go-build133979866\b001\exe\main. //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:\gostudent\src\2020-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数据在线解析
网站可以验证一个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 \n", err) } //输出序列化后的结果 fmt.printf("monster 序列化后 = %v \n", 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 \n", err) } //输出序列化后的结果 fmt.printf("monster 序列化后 = %v \n", 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 \n", err) } //输出序列化后的结果 fmt.printf("monster 序列化后 = %v \n", string(data)) } //对基本数据类型序列化,意义不大 func testfloat64() { var num1 float64 = 2345.67 //对num1进行序列化 data, err := json.marshal(num1) if err != nil { fmt.printf("序列号错误 err = %v \n", err) } //输出序列化后的结果 fmt.printf("monster 序列化后 = %v \n", 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 \n", err) } //输出序列化后的结果 fmt.printf("monster 序列化后 = %v \n", 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\n", err) } fmt.printf("反序列化后 monster = %v monster.name = %v \n", 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\n", err) } fmt.printf("反序列化后 a = %v\n",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\n", err) } fmt.printf("反序列化后 slice = %v\n", 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\n ", res, 55) } else { fmt.printf("addupper正确 返回值 = %v 期望值 = %v\n", 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() 测试成功!") }