Go第 14 章 :文件操作
14.1 文件的基本介绍
文件的概念
文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的 word文档,txt文 件,excel 文件…都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声 音…
输入流和输出流
os.File 封装所有文件相关操作,File 是一个结构体
14.2 打开文件和关闭文件
14.3 读文件操作应用实例
- 读取文件的内容并显示在终端(带缓冲区的方式),使用 os.Open, file.Close, bufio.NewReader(), reader.ReadString 函数和方法.
代码实现:
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
//打开一个文件
//概念:file叫法
//1、file对象
//2、file指针
//3、文件句柄
file, err := os.Open("/Users/tianyi/Desktop/杨璐羽论文/查重报告.html")
if err != nil {
fmt.Println("openfile err=", err)
}
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)//如果用Println将会有两个换行
}
fmt.Println("文件读取结束...")
}
- 读取文件的内容并显示在终端(使用 ioutil 一次将整个文件读入到内存中),这种方式适用于文件 不大的情况。相关方法和函数(ioutil.ReadFile)
package main
import (
"fmt"
"os"
)
func main(){
//使用ioutil.ReadFile一次性将文件读取的到位
file := "/Users/tianyi/Desktop/杨璐羽论文/查重报告.html"
content,err :=os.ReadFile(file)
if err!=nil{
fmt.Printf("read file err=%v",err)
}
//把读取到的内容显示到终端
//fmt.Printf("%v",content)
fmt.Printf("%v",string(content))
//我们没有显式的open文件,因此也不需要显式的close文件
//因为,文件的open和close被封装到ReadFile函数内部
}
14.4 写文件操作应用实例
14.4.1 基本介绍-os.OpenFile 函数
14.4.2 基本应用实例-方式一
- 创建一个新文件,写入内容 5 句 “hello, Gardon”
- 打开一个存在的文件中,将原来的内容覆盖成新的内容 10 句 “你好,尚硅谷!”
package main
import (
"bufio"
"fmt"
"os"
)
func main(){
filePath:="/Users/tianyi/Desktop/tianyi.txt"
file ,err:=os.OpenFile(filePath,os.O_WRONLY|os.O_TRUNC,0666)
if err!=nil{
fmt.Println("open file err=",err)
return
}
defer file.Close()
str:="你好,田毅!\r\n" // \r\n 表示换行
writer:=bufio.NewWriter(file)
for i:=0;i<10;i++{
writer.WriteString(str)
}
writer.Flush()
}
- 打开一个存在的文件,在原来的内容追加内容 ‘ABC! ENGLISH!’
package main
import (
"bufio"
"fmt"
"os"
)
func main(){
filePath:="/Users/tianyi/Desktop/tianyi.txt"
file,err := os.OpenFile(filePath,os.O_WRONLY|os.O_APPEND,0666)
if err!=nil{
fmt.Println("open file err=",err)
return
}
defer file.Close()
str:="ABC,English!\r\n"
writer:=bufio.NewWriter(file)
for i:=0;i<10;i++{
writer.WriteString(str)
}
writer.Flush()
}
- 打开一个存在的文件,将原来的内容读出显示在终端,并且追加 5 句"hello,北京!"
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main(){
filePath:="/Users/tianyi/Desktop/tianyi.txt"
file,err := os.OpenFile(filePath,os.O_RDWR|os.O_APPEND,0666)
if err!=nil{
fmt.Println("open file err=",err)
return
}
defer file.Close()
reader := bufio.NewReader(file)
for{
str,err:=reader.ReadString('\n')
if err ==io.EOF{
break
}
fmt.Print(str)
}
str1:="你好,杨璐羽!!\r\n"
writer:=bufio.NewWriter(file)
for i:=0;i<5;i++{
writer.WriteString(str1)
}
writer.Flush()
}
14.4.3 基本应用实例-方式二
编程一个程序,将一个文件的内容,写入到另外一个文件。注:这两个文件已经存在了.
说明:使用 ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务.
代码实现:
package main
import (
"fmt"
"io/ioutil"
)
func main (){
file1path :="/Users/tianyi/Desktop/tianyi.txt"
file2path := "/Users/tianyi/Desktop/tianyi2.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",err)
}
}
14.4.4 判断文件是否存在
14.5 文件编程应用实例
14.5.1 拷贝文件
说明:将一张图片/电影/mp3 拷贝到另外一个文件 e:/abc.jpg io包
func Copy(dst Writer, src Reader) (written int64, err error)
注意; Copy 函数是 io包提供的.
代码实现:
package main
import (
"bufio"
"fmt"
"io"
"os"
)
//自己编写一个函数,接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string,srcFileName string)(written int64,err error){
srcFile,err:=os.Open(srcFileName)
if err!=nil{
fmt.Println("open file err=",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.Println("open file err=",err)
return
}
//通过 dstFile, 获取到 Writer
writer:=bufio.NewWriter(dstFile)
defer dstFile.Close()
return io.Copy(writer,reader)
}
func main(){
//将 d:/flower.jpg 文件拷贝到 e:/abc.jpg
srcFile :="/Users/tianyi/Desktop/abc.png"
dstFile :="/Users/tianyi/Desktop/def.png"
_,err:=CopyFile(dstFile,srcFile)
if err==nil{
fmt.Println("copy success")
}else{
fmt.Println("拷贝错误",err)
}
}
14.5.2 统计英文、数字、空格和其他字符数量
说明:统计一个文件中含有的英文、数字、空格及其它字符数量
代码实现:
package main
import (
"bufio"
"fmt"
"io"
"os"
)
//定义一个结构体,用于保存统计结果
type CharCount struct {
WordCount int
NumCount int
SpaceCount int
OtherCount int
}
func main() {
//思路: 打开一个文件, 创一个 Reader
//每读取一行,就去统计该行有多少个 英文、数字、空格和其他字符
//然后将结果保存到一个结构体
fileName := "/Users/tianyi/Desktop/tianyi.txt"
file, err := os.Open(fileName)
if err != nil {
fmt.Println("open file err", err)
return
}
defer file.Close()
//定义个CharCount实例
var count CharCount
//创建一个Reader
reader := bufio.NewReader(file)
//开始循环的读取fileName的内容
for {
str, err := reader.ReadString('\n')
if err == io.EOF {
//读取到文本的末尾就退出
break
}
//为了兼容中文字符,可以将str转成[]rune
str = string([]rune(str))
//遍历 str ,进行统计
for _, v := range str {
switch {
case v >= 'a' && v < 'z':
fallthrough //穿透
case v >= 'A' && v < 'Z':
count.WordCount++
case v == ' ' || v == '\t':
count.SpaceCount++
case v >= '0' && v < '9':
count.NumCount++
default:
count.OtherCount++
}
}
}
//输出统计的结果看看是否正确
fmt.Printf("字符的个数为=%v 数字的个数为=%v 空格的个数为=%v 其它字符个数=%v",
count.WordCount, count.NumCount, count.SpaceCount, count.OtherCount)
}
14.6 命令行参数
14.6.1 看一个需求
我们希望能够获取到命令行输入的各种参数,该如何处理? 如图:=> 命令行参数
14.6.2 基本介绍
os.Args 是一个 string 的切片,用来存储所有的命令行参数
14.6.3 举例说明
请编写一段代码,可以获取命令行各个参数
14.6.4 flag 包用来解析命令行参数
说明: 前面的方式是比较原生的方式,对解析参数不是特别的方便,特别是带有指定参数形式的命
令行。
比如:cmd>main.exe -f c:/aaa.txt -p 200 -u root 这样的形式命令行,go 设计者给我们提供了 flag 包,可以方便的解析命令行参数,而且参数顺序可以随意
14.7 json 基本介绍
概述
14.8 json 数据格式说明
14.9 json 数据在线解析
https://www.json.cn/ 网站可以验证一个 json 格式的数据是否正确。尤其是在我们编写比较复杂的 json 格式数据时,很有用。
14.10 json 的序列化
package main
import (
"encoding/json"
"fmt"
)
type Monster struct{
Name string
Age int
Birthday string
Sal float64
Skill string
}
func testStruct(){
//演示:
monster:=Monster{
Name:"牛魔王",
Age:500,
Birthday: "2011-11-11",
Sal:8000.0,
Skill:"牛魔拳",
}
//将monster序列化
data,err:=json.Marshal(&monster)
if err!=nil{
fmt.Printf("Struct序列号错误err=%v\n",err)
}
//输出序列化之后的结果
fmt.Printf("Struct序列化后%v\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"]="洪崖洞"
//将这个map进行序列化
data,err:=json.Marshal(a)
if err!=nil{
fmt.Printf("map序列化错误err=%v\n",err)
}
fmt.Printf("map序列化后=%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"]=18
m1["adress"]="北京"
slice=append(slice,m1)
var m2 map[string]interface{}
//使用map前,需要先make
m2=make(map[string]interface{})
m1["name"]="tom"
m1["age"]=20
m1["adress"]="天津"
slice=append(slice,m2)
//将切片进行序列化操作
data,err:=json.Marshal(slice)
if err!=nil{
fmt.Println("Slice序列化错误,err=",err)
}
//输出序列化后的结果
fmt.Println("Slice序列化后的结果为:",data)
}
//对基本数据类型序列化,对基本数据类型进行序列化意义不大
func testFloat32(){
var num1 float64=2345.67
//对num1进行序列化
data,err:=json.Marshal(num1)
if err!=nil{
fmt.Println("Float序列化发生错误,err=",err)
}
fmt.Println("Float序列化后的结果为:",data)
}
func main(){
testSlice()
testMap()
testFloat32()
testStruct()
}
注意事项
对于结构体的序列化,如果我们希望序列化后的 key的名字,又我们自己重新制定,那么可以给 struct 指定一个 tag标签.
type Monster struct{
Name string `json:"monster_name"`
Age int `json:"monster_age"`
Birthday string
Sal float64
Skill string
}
序列化后:
{“monster_name”:“牛魔王”,“monster_age”:500,“Birthday”:“2011-11-11”,“Sal”:8000,“Skill”:“牛魔拳”}
14.11json 的反序列化
基本介绍
json 反序列化是指,将 json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作
这里我们介绍一下将 json字符串反序列化成结构体、map 和切片
代码演示:
package main import (
"fmt"
"encoding/json" )
//定义一个结构体 type Monster struct {
Name string
Age int
Birthday string //....
Sal float64
Skill string }
//演示将 json 字符串,反序列化成 struct
func unmarshalStruct() {
//说明 str 在项目开发中,是通过网络传输获取到.. 或者是读取文件获取到
str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-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 字符串,反序列化成切片
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()
}
###### 对上面代码的小结说明
1) 在反序列化一个 json 字符串时,要确保反序列化后的数据类型和原来序列化前的数据类型一致。
2) 如果 json 字符串是通过程序获取到的,则不需要再对 “ 转义处理。
![请添加图片描述](https://img-blog.csdnimg.cn/0218a84f127f49a8b4888c5542810888.png)