Go学习笔记（12）-文件操作

原创
AWhiteElephant
2022-05-26
Golang
436
0

Go学习笔记（12）

文件操作

文件的基本介绍

文件的概念

​ 文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的 word 文档,txt 文件,excel 文件...都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声音...

输入流和输出流

os.File 封装所有文件相关操作，File 是一个结构体

总结：后面我们操作文件，会经常使用到 os.File 结构体.

打开文件和关闭文件

使用的函数和方法

案例演示

读文件操作应用实例

  1. 读取文件的内容并显示在终端(带缓冲区的方式)，使用 os.Open, file.Close, bufio.NewReader(),reader.ReadString 函数和方法.

代码实现：

package main

import (
    "fmt"
    "os"
    "bufio"
    "io"
)

func main() {
    //打开文件
    //概念说明: file 的叫法
    //1. file 叫 file 对象
    //2. file 叫 file 指针
    //3. file 叫 file 文件句柄
    file , err := os.Open("d:/test.txt")
    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("文件读取结束...")
}
  1. 读取文件的内容并显示在终端(使用 ioutil 一次将整个文件读入到内存中)，这种方式适用于文件不大的情况。相关方法和函数(ioutil.ReadFile)

代码演示：

写文件操作应用实例

基本介绍-os.OpenFile 函数

基本应用实例-方式一

  1. 创建一个新文件，写入内容 5 句 "hello, Gardon"

    代码实现：

  1. 打开一个存在的文件中，将原来的内容覆盖成新的内容 10 句 "你好，尚硅谷!"
package main
import (
    "fmt"
    "bufio"
    "os"
)

func main() {
    //打开一个存在的文件中，将原来的内容覆盖成新的内容 10 句 "你好，尚硅谷!"
    //创建一个新文件，写入内容 5 句 "hello, Gardon"
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/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()
    
    //准备写入 5 句 "你好,尚硅谷!"
    str := "你好,尚硅谷!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
    	writer.WriteString(str)
    }
    //因为 writer 是带缓存，因此在调用 WriterString 方法时，其实
    //内容是先写入到缓存的,所以需要调用 Flush 方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
}

  1. 打开一个存在的文件，在原来的内容追加内容 'ABC! ENGLISH!'

    代码实现：

package main

import (
    "fmt"
    "bufio"
    "os"
)

func main() {
    //打开一个存在的文件，在原来的内容追加内容 'ABC! ENGLISH!'
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/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()
    //准备写入 5 句 "你好,尚硅谷!"
    str := "ABC,ENGLISH!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
    	writer.WriteString(str)
    }
    //因为 writer 是带缓存，因此在调用 WriterString 方法时，其实
    //内容是先写入到缓存的,所以需要调用 Flush 方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
}

  1. 打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句"hello,北京!"

    代码实现：

package main
import (
    "fmt"
    "bufio"
    "os"
    "io"
)
func main() {
    //打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句"hello,北京!"
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/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)
    }
    //准备写入 5 句 "你好,尚硅谷!"
    str := "hello,北京!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
    	writer.WriteString(str)
    }
    //因为 writer 是带缓存，因此在调用 WriterString 方法时，其实
    //内容是先写入到缓存的,所以需要调用 Flush 方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
}

基本应用实例-方式二

编程一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了.

说明：使用 ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务.

代码实现：

判断文件是否存在

文件编程应用实例

拷贝文件

说明：将一张图片/电影/mp3 拷贝到另外一个文件 e:/abc.jpg io 包

func Copy(dst Writer, src Reader) (written int64, err error)

注意; Copy 函数是 io 包提供的.

代码实现：

package main

import (
    "fmt"
    "os"
    "io"
    "bufio"
)

//自己编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName 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:/flower.jpg 文件拷贝到 e:/abc.jpg
    //调用 CopyFile 完成文件拷贝
    srcFile := "d:/flower.jpg"
    dstFile := "e:/abc.jpg"
    _, err := CopyFile(dstFile, srcFile)
    if err == nil {
    	fmt.Printf("拷贝完成\n")
    } else {
    	fmt.Printf("拷贝错误 err=%v\n", err)
    }
}

统计英文、数字、空格和其他字符数量

说明：统计一个文件中含有的英文、数字、空格及其它字符数量

代码实现：

package main
import (
    "fmt"
    "os"
    "io"
    "bufio"
)
//定义一个结构体，用于保存统计结果
type CharCount struct {
    ChCount int // 记录英文个数
    NumCount int // 记录数字的个数
    SpaceCount int // 记录空格的个数
    OtherCount int // 记录其它字符的个数
}

func main() {
    //思路: 打开一个文件, 创一个 Reader
    //每读取一行，就去统计该行有多少个 英文、数字、空格和其他字符
    //然后将结果保存到一个结构体
    fileName := "e:/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)
    //开始循环的读取 fileName 的内容
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //读到文件末尾就退出
        break
    }
        
    //为了兼容中文字符, 可以将 str 转成 []rune
    // str = []run(str)
    //遍历 str ，进行统计
    for _, v := range str {  // 其实for .. range 已经可以对中文字符进行统计
        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 的切片，用来存储所有的命令行参数

举例说明

请编写一段代码，可以获取命令行各个参数

代码实现:

flag 包用来解析命令行参数

说明: 前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命令行。

比如：cmd>main.exe -f c:/aaa.txt -p 200 -u root 这样的形式命令行，go 设计者给我们提供了 flag包，可以方便的解析命令行参数，而且参数顺序可以随意

请编写一段代码，可以获取命令行各个参数.

代码实现：

json 基本介绍

概述

应用场景(示意图)

json 数据格式说明

json 数据在线解析

https://www.json.cn/ 网站可以验证一个 json 格式的数据是否正确。尤其是在我们编写比较复杂的json 格式数据时，很有用。

json 的序列化

介绍

json 序列化是指，将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成 json 字符串的操作。

应用案例

这里我们介绍一下结构体、map 和切片的序列化，其它数据类型的序列化类似。

代码演示

package main
import (
    "fmt"
    "encoding/json"
)

//定义一个结构体
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("序列号错误 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 进行序列化
    //将 monster 序列化
    data, err := json.Marshal(a)
    if err != nil {
    	fmt.Printf("序列化错误 err=%v\n", err)
	}
    //输出序列化后的结果
    fmt.Printf("a 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"] = "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("slice 序列化后=%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("num1 序列化后=%v\n", string(data))
}

func main() {
    //演示将结构体, map , 切片进行序列号
    testStruct()
    testMap()
    testSlice()//演示对切片的序列化
    testFloat64()//演示对基本数据类型的序列化
}

注意事项

对于结构体的序列化，如果我们希望序列化后的 key 的名字，又我们自己重新制定，那么可以给 struct指定一个 tag 标签.

序列化后：

{"monster_name":"牛魔王","monster_age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}

json 的反序列化

基本介绍

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 字符串是通过程序获取到的，则不需要再对 “ 转义处理。
end
  • 作者：AWhiteElephant（联系作者）
  • 发表时间：2022-05-26 15:56
  • 版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）
  • 转载声明：如果是转载栈主转载的文章，请附上原文链接
    •

    评论