go-文件操作

章文件操作

文件的基本介绍

文件的概念

文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的 word 文档,txt 文
件,excel 文件...都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声
音...
输入流和输出流
os.file 封装所有文件相关操作，file 是一个结构体

打开文件和关闭文件

使用的函数和方法

package main
import (
    "fmt"
    "os" 
)
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 就是一个指针 *file
    fmt.printf("file=%v", file)//如果文件不存在file=<nil>
    //关闭文件
    err = file.close()
    if err != nil {
        fmt.println("close file err=", err)
    }
}

读文件操作应用实例

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.printf(str)
    }

    fmt.println("文件读取结束...")
}

2) 读取文件的内容并显示在终端(使用 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("read file err=%v", err)
    }
    //把读取到的内容显示到终端
    //fmt.printf("%v", content) // []byte
    fmt.printf("%v", string(content)) // []byte
    
    //我们没有显式的open文件，因此也不需要显式的close文件
    //因为，文件的open和close被封装到 readfile 函数内部
}

写文件操作应用实例

基本介绍-os.openfile 函数

　基本应用实例-方式一

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

package main
import (
    "fmt"
    "bufio"
    "os" 
)
func main() {
    //创建一个新文件，写入内容 5句 "hello, gardon"
    //1 .打开文件 d:/abc.txt
    filepath := "d:/abcd.txt"
    file, err := os.openfile(filepath, os.o_wronly | os.o_create, 0666)
    if err != nil {
        fmt.printf("open file err=%v\n", err)
        return 
    }
    //及时关闭file句柄
    defer file.close()
    //准备写入5句 "hello, gardon"
    str := "hello,gardon\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *writer
    writer := bufio.newwriter(file)
    for i := 0; i < 5; i++ {
        writer.writestring(str)
    }
    //因为writer是带缓存，因此在调用writerstring方法时，其实
    //内容是先写入到缓存的,所以需要调用flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.flush()
}

1) 打开一个存在的文件中，将原来的内容覆盖成新的内容 10 句 "你好，ygj!"

package main
import (
    "fmt"
    "bufio"
    "os" 
)

func main() {
    //打开一个存在的文件中，将原来的内容覆盖成新的内容10句 "你好，ygj!"

    //创建一个新文件，写入内容 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句 "你好,ygj!"
    str := "你好,ygj!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *writer
    writer := bufio.newwriter(file)
    for i := 0; i < 10; i++ {
        writer.writestring(str)
    }
    //因为writer是带缓存，因此在调用writerstring方法时，其实
    //内容是先写入到缓存的,所以需要调用flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.flush()

}

2) 打开一个存在的文件，在原来的内容容 追加内容 '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句 "你好,ygj!"
    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()

}

3) 打开一个存在的文件，将原来的内容 读出显示在终端，并且 追加 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句 "你好,ygj!"
    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 完成写文件的任务.

package main
import (
    "fmt"
    "io/ioutil" 
)
func main() {
    //将d:/abc.txt 文件内容导入到  d:/abcd.txt
    //1. 首先将  d:/abc.txt 内容读取到内存
    //2. 将读取到的内容写入 d:/abcd.txt
    file1path := "d:/abc.txt" 
    file2path := "d:/abcd.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)
    }
}

文件编程应用实例

　拷贝文件

说明：将一张图片/电影/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 ，进行统计
        for _, v := range str {
            
            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 的切片，用来存储所有的命令行参数
参数加在go run main.go的后面即可；

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)
    }
}

flag 包用来解析命令行参数

说明: 前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命
令行。
比如：cmd>main.exe -f c:/aaa.txt -p 200 -u root 这样的形式命令行，go 设计者给我们提供了 flag
包，可以方便的解析命令行参数，而且参数顺序可以随意
请编写一段代码，可以获取命令行各个参数.

package main
import (
    "fmt"
    "flag"
)

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)

}

json 基本介绍

json 数据格式说明

json 数据在线解析[] 网站可以验证一个 json 格式的数据是否正确。尤其是在我们编写比较复杂的
json 格式数据时，很有用

json 的序列化

介绍
json 序列化是指，将有 key-value 结构的数据类型(比如 结构体、map 、切片)序列化成 json 字符串的操作。
应用案例
这里我们介绍一下 结构体、map 和切片的序列化，其它数据类型的序列化类似。

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

//定义一个结构体
type monster struct {
    name string `json:"monster_name"` //反射机制
    age int `json:"monster_age"`
    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 标签.

　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)

}
//将map进行序列化
func testmap() string {
    //定义一个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))
    return string(data)

}

//演示将json字符串，反序列化成map
func unmarshalmap() {
    //str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
    str := testmap()
    //定义一个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 字符串是通过程序获取到的，则不需要再对 “ 转义处理。