文件操作

文件操作

文件的基本介绍

文件是数据源(保存数据的地方)的一种，比如大家经常使用的 word 文档，txt 文件，excel 文件…都是文件。
文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保持视频，声音…。
文件在程序中是以流的形式来操作的。
- 流：数据在数据源(文件)和程序(内存)之间经历的路径。
- 输入流：数据从数据源(文件)道程序(内存)的路径 —> 读文件
- 输出流：数据从程序(内存)到数据源(文件)的路径。—> 写文件
os.File 封装所有文件相关操作，File 是一个结构体。

常用的文件操作函数和方法
打开一个文件进行读操作：
```
os.Open(name string)(*File, error)
```
关闭一个文件：
```
File.Close()
```
打开和关闭文件相关案例 ```go 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 error: ", err)
}
//输出下文件，看看文件是什么
fmt.Printf("file = %v\n", file)
//关闭文件
err = file.Close()
if err != nil {
    fmt.Println("close file error: ", err)
}

}


4. 其他的函数和方法在案例讲解
<a name="7cf8ef7d"></a>
## 读文件操作应用实例
1. 读取文件的内容并显示在终端(带缓存区的方式)，使用os.Open，File.Close，bufio.NewReader()，reader.Readstring 函数和方法。
```go
package main
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
func main() {
    // 打开文件
    // 概念说明：file 的叫法
    //1. file 叫 file 对象
    //2. file 叫 file 指针
    //3. file 叫 file 文件句柄
    file, err := os.Open("/Users/mac/Desktop/Linux/phonelist.txt")
    if err != nil {
        fmt.Println("open file error: ", 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)。 ```go package main

import ( “fmt” “io/ioutil” )

func main() { //使用 ioutil.ReadFile 一次性将文件读取到位 file := “/Users/mac/Desktop/Linux/phonelist.txt” content, err := ioutil.ReadFile(file) if err != nil { fmt.Println(“read file err: “,err) } //把读取到的内容显示到终端 fmt.Println(string(content)) //[]byte

//因为，我们没有显式的 open文件，因此也不需要显式的 close 文件
//因为，文件的 open 和 close 被封装到 ReadFile 函数内部

}

<a name="31ee2e79"></a>
## 写文件操作应用实例
<a name="f72dd4a6"></a>
### 基本介绍
1. func OpenFile(name string, flag int, perm FileMode)(file *File, err error) 
1. 说明 
   - os.OpenFile是一个更一般性的文件打开函数，它会使用指定的选项(如O_RDONLY等)、指定的模式(如0666等)打开指定名称的文件。 
   - 如果操作成功，返回的文件对象可用于 I/O 。如果出错，错误底层类型是 *PathError 。 
<a name="261f947c"></a>
### 基本应用实例-方式一
1. 创建一个新文件，写入内容 5 句 "hello，Gardon"
```go
package main
import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    //创建一个新文件，写入内容5句"hello，Gordon"
    //1. 打开文件
    filePath := "/Users/mac/Desktop/Linux/print.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_CREATE, 0755)
    if err != nil {
        fmt.Println("open file error: ", err)
        return
    }
    //及时关闭 file 句柄
    defer func() {
        err = file.Close()
        if err != nil {
            fmt.Println("close file error: ", err)
        }
    }()
    //准备写入5句"hello，Gordon"
    str := "hello，Gordon\n"
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i:=0; i < 5; i++ {
        _, err = writer.WriteString(str)
        if err != nil {
            fmt.Println("write file error: ", err)
        }
    }
    /*
        因为 writer 是带缓存，因此在调用 WriteString 方法时，其实内容是先写入缓存的，
        所以需要调用 flush() 方法将缓存的内容真正写入到文件中，否则文件中会没有数据
    */
    err = writer.Flush()
    if err != nil {
        fmt.Println("flush error: ", err)
    }
}

打开一个存在的文件，将原来的内容覆盖成新的内容 10 句 “你好，尚硅谷!” ```go package main

import ( “bufio” “fmt” “os” )

func main() { //打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好，尚硅谷!” filePath := “/Users/mac/Desktop/Linux/print.txt” file, err := os.OpenFile(filePath, os.O_TRUNC | os.O_WRONLY, 0755) if err != nil { fmt.Println(“open file error: “, err) return }

//及时关闭 file 句柄
defer func() {
    err = file.Close()
    if err != nil {
        fmt.Println("close file error: ", err)
    }
}()
//准备写入10句"你好，尚硅谷!"
str := "你好，尚硅谷!\r\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i:=0; i< 10; i++ {
    _, err = writer.WriteString(str)
    if err != nil {
        fmt.Println("write file error: ", err)
    }
}
/*
    因为 writer 是带缓存，因此在调用 WriteString 方法时，其实内容是先写入缓存的，
    所以需要调用 flush() 方法将缓存的内容真正写入到文件中，否则文件中会没有数据
*/
err = writer.Flush()
if err != nil {
    fmt.Println("flush error: ", err)
}

}


3. 打开一个存在的文件，在原来的内容追加内容 "ABC!ENGLISH"
```go
package main
import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    //打开一个存在的文件，在原来的内容追加内容“ABC!ENGLISH”
    filePath := "/Users/mac/Desktop/Linux/print.txt"
    file, err := os.OpenFile(filePath, os.O_APPEND | os.O_WRONLY, 0755)
    if err != nil {
        fmt.Println("open file error: ", err)
        return
    }
    //及时关闭 file 句柄
    defer func() {
        err = file.Close()
        if err != nil {
            fmt.Println("close file error: ", err)
        }
    }()
    //准备写入追加内容“ABC!ENGLISH”
    str := "ABC!ENGLISH\r\n"
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i:=0; i< 10; i++ {
        _, err = writer.WriteString(str)
        if err != nil {
            fmt.Println("write file error: ", err)
        }
    }
    /*
        因为 writer 是带缓存，因此在调用 WriteString 方法时，其实内容是先写入缓存的，
        所以需要调用 flush() 方法将缓存的内容真正写入到文件中，否则文件中会没有数据
    */
    err = writer.Flush()
    if err != nil {
        fmt.Println("flush error: ", err)
    }
}

打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句 “hello,北京!” ```go package main

import ( “bufio” “fmt” “io” “os” )

func main() {

//打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句 "hello,北京!"
filePath := "/Users/mac/Desktop/Linux/print.txt"
file, err := os.OpenFile(filePath, os.O_RDWR | os.O_APPEND, 0755)
if err != nil {
    fmt.Println("open file error: ", err)
    return
}
//及时关闭 file 句柄
defer func() {
    err = file.Close()
    if err != nil {
        fmt.Println("close file error: ", err)
    }
}()
//先读取原来文件的内容，并显示在终端。
reader := bufio.NewReader(file)
for {
    str, err := reader.ReadString('\n')
    if err == io.EOF {
        //io.EOF 表示文件末尾
        break
    }
    //输出内容
    fmt.Print(str)
}
//准备写入追加5句"hello,北京!"
str := "hello,北京!\r\n"
//写入时，使用带缓存的 *Writer
writer := bufio.NewWriter(file)
for i:=0; i< 5; i++ {
    _, err = writer.WriteString(str)
    if err != nil {
        fmt.Println("write file error: ", err)
    }
}
/*
    因为 writer 是带缓存，因此在调用 WriteString 方法时，其实内容是先写入缓存的，
    所以需要调用 flush() 方法将缓存的内容真正写入到文件中，否则文件中会没有数据
*/
err = writer.Flush()
if err != nil {
    fmt.Println("flush error: ", err)
}

}

<a name="1e90a363"></a>
### 基本应用实例-方式二
1. 编写一个程序，将一个文件的内容，写入到另一个文件。注：这两个文件已经存在了。
1. 说明：使用 ioutil.ReadFile / ioutil.Writer 完成写文件的任务。
```go
package main
import (
    "fmt"
    "io/ioutil"
)
func main() {
    //将 /Users/mac/Desktop/Linux/phonelist.txt 文件内容导入到 /Users/mac/Desktop/Linux/print.txt
    //1. 首先将 /Users/mac/Desktop/Linux/phonelist.txt 读取到内存
    //2. 将读取到的内容写入 /Users/mac/Desktop/Linux/print.txt
    file1Path := "/Users/mac/Desktop/Linux/phonelist.txt"
    file2Path := "/Users/mac/Desktop/Linux/print.txt"
    content, err := ioutil.ReadFile(file1Path)
    if err != nil {
        //说明读取文件有错误
        fmt.Println("read file error:", err)
        return
    }
    err = ioutil.WriteFile(file2Path, content, 0755)
    if err != nil {
        fmt.Println("write file error:", err)
    }
}

判断文件是否存在

Golang 判断文件或文件夹是否存在的方法为使用 os.Stat() 函数返回的错误值进行判断：
- 如果返回的错误为 nil，说明文件或文件夹存在
- 如果返回的错误类型使用 os.IsNotExist() 判断为 true，说明文件或文件夹不存在
- 如果返回的错误为其他类型，则不确定是否存在。

代码

func PathExists(path string) (bool error) {
 _, err := os.Stat(path)
 if err == nil {
     //文件或者目录存在
     return true,nil
 }
 if os.IsNotExist(err) {
     return false,nil
 }
 return false,err
}

文件编程应用实例

拷贝文件

说明：将一张图片/电影/mp3拷贝到另一个文件下。 ```go 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 error: “, err) return }

//构建 srcfile ，获取到 Reader
reader := bufio.NewReader(srcfile)
//打开 dstFileName
dstfile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0644)
if err != nil {
    fmt.Println("open file error: ", err)
    return
}
//构建 dstfile ，获取到 Writer
writer := bufio.NewWriter(dstfile)
defer func() {
    err = srcfile.Close()
    if err != nil {
        fmt.Println("close file error: ", err)
    }
}()
defer func() {
    err = dstfile.Close()
    if err != nil {
        fmt.Println("close file error: ", err)
    }
}()
return io.Copy(writer, reader)

}

func main() {

//将 /Users/mac/Desktop/PersonalWork/01.jpg 文件拷贝到 /Users/mac/Desktop/Linux/02.jpg
//调用 CopyFile 完成文件拷贝
srcFile := "/Users/mac/Desktop/PersonalWork/01.jpg"
dstFile := "/Users/mac/Desktop/Linux/02.jpg"
_, err := CopyFile(dstFile, srcFile)
if err == nil {
    fmt.Println("拷贝完成")
} else {
    fmt.Println("拷贝错误：", err)
}

}

<a name="d4cff46b"></a>
### 统计一个文件中含有的英文、数字、空格及其他字符数量。
1. 说明：统计一个文件中含有英文、数字、空格及其它字符数量。
```go
package main
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
//定义一个结构体，用于保存统计结果
type CharCount struct {
    ChCount int // 记录英文个数
    NumCount int // 记录数字个数
    SpaceCount int //记录空格的个数
    OtherCount int //记录其他字符的个数
}
func main() {
    //思路：打开一个文件，创建一个 Reader
    //每读取一行，就去统计该行有多少个 英文、数字、空格和其他字符
    //然后将结果保存到一个结构体中
    fileName := "/Users/mac/Desktop/Linux/distros.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Print("open file error: ", err)
        return
    }
    defer func() {
        err = file.Close()
        if err != nil {
            fmt.Println("close file error: ", err)
        }
    }()
    //定义一个 CharCount 实例
    var count CharCount
    //创建一个 Reader
    reader := bufio.NewReader(file)
    //开始循环的读取 fileName 的内容
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //读到文件末尾就退出
            break
        }
        //遍历 str ，进行统计
        for _, value := range str {
            switch {
                case value >= 'a' && value <= 'z':
                    fallthrough //穿透
                case value >= 'A' && value <= 'Z':
                    count.ChCount++
                case value == ' ' || value == '\t':
                    count.SpaceCount++
                case value >= '0' && value <= '9':
                    count.NumCount++
                default:
                    count.OtherCount++
            }
        }
    }
    //输出统计的结果看看是否正确
    fmt.Printf("字符的个数为%v 数字的个数为%v 空格的个数为%v 其他字符的个数为%v", count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}

命令行参数

命令行参数一

需求

我们希望能获取到命令行输入的各种参数，该如何处理？

基本介绍
os.Args 是一个 string 的切片，用来存储所有的命令行参数。

案例说明
案例一 ```go package main

import ( “fmt” “os” )

func main() {

fmt.Println("命令行参数有: ", len(os.Args))
// 遍历 os.Args 切片，就可以得到所有命令行输入参数值
for index, value := range os.Args {
    fmt.Printf("args[%v] = %v \n", index, value)
}

}

<a name="2fdf61ce"></a>
### 命令行参数二
<a name="6e274dcf"></a>
#### flag 包用来解析命令行参数
1. 说明：前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命令行。
1. 比如：`cmd > main.exe -f c:/aaa.txt -p 200 -u root` 这样的形式命令行，go 设计者给我们提供了 flag 包，可以方便的解析命令行参数，而且参数顺序可以随意。
<a name="f05aba5b-1"></a>
#### 案例说明
1. 案例一
```go
package main
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)
}

json

json 的基本介绍

json(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。
json 是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式。
json 易于机器解析和生成，并有效地提升网络传输效率，通常程序在网络插损胡时会先将数据(结构体、map等)序列化成 json 字符串，到接受方得到 json 字符串时，在反序列话恢复成原来的数据类型(结构体、map等)。这种方式已然成为各个语言的标准。

json 数据格式说明
在 js 语言中，一切都是对象。因此，任何支持的类型都可以通过 json 来表示，例如：字符串、数字、对象、数组等。
json 键值对是用来保存数据一种方式，键/值对组合中的键名写在前面并用双引号””包裹，使用冒号:分隔，然后紧接着值。

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

json 的序列化

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

应用案例
struct 序列化 ```go package main

import ( “encoding/json” “fmt” )

//定义一个结构体 type Monster struct { Name string Age int Birthday string Salary float64 Skill string }

func testStruct() { //演示 monster := Monster{ Name: “牛魔王”, Age: 500, Birthday: “2011-11-11”, Salary: 8000.0, Skill: “牛魔拳”, }

//将 monster 序列化
data, err := json.Marshal(&monster)
if err !=nil {
    fmt.Println("序列化错误 error: ", err)
} else {
    //输出序列化后的结果
    fmt.Printf("monster序列化后 = %v \n", string(data))
}

}

func main() { //演示将结构体、map、切片进行序列化 testStruct()

}


2. map 序列化
```go
package main
import (
    "encoding/json"
    "fmt"
)
//将 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.Println("a 序列化错误 error: ", err)
    } else {
        //输出序列化后的结果
        fmt.Printf("a 序列化后 = %v \n", string(data))
    }
}
func main() {
    //调用 testMap
    testMap()
}

slice 序列化 ```go package main

import ( “encoding/json” “fmt” )

//演示对切片进行序列化，我们切片 []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"] = "墨西哥"
slice = append(slice, m2)
//将切片进行序列化操作
data, err := json.Marshal(slice)
if err != nil {
    fmt.Println("slice 序列化错误 error: ", err)
} else {
    //输出序列化后的结果
    fmt.Printf("slice 序列化后 = %v \n", string(data))
}

}

func main() { //调用 testSlice，演示对切片的序列化 testSlice()

}


4. 基本数据类型序列化
```go
package main
import (
    "encoding/json"
    "fmt"
)
//对基本数据类型序列化，意义不大
func testFloat64() {
    var num1 float64 = 2345.67
    //对 num1 进行序列化
    data, err := json.Marshal(num1)
    if err != nil {
        fmt.Println("num1 序列化错误 error: ", err)
    } else {
        fmt.Printf("num1 序列化后 = %v \n", string(data))
    }
}
func main() {
    //演示对基本数据类型的序列化
    testFloat64()
}

注意事项：对于结构体的序列化，如果我们希望序列化后的 key 的名字，我们自己重新指定，那么可以给 struct 指定一个 tag 标签即可。 ```go package main

import ( “encoding/json” “fmt” )

//定义一个结构体 type Monster struct { Name string json:"name" //反射机制 Age int json:"age" Birthday string json:"birthday" Salary float64 json:"salary" Skill string json:"skill" }

func testStruct() { //演示 monster := Monster{ Name: “牛魔王”, Age: 500, Birthday: “2011-11-11”, Salary: 8000.0, Skill: “牛魔拳”, }

//将 monster 序列化
data, err := json.Marshal(&monster)
if err !=nil {
    fmt.Println("monster 序列化错误 error: ", err)
} else {
    //输出序列化后的结果
    fmt.Printf("monster 序列化后 = %v \n", string(data))
}

}

func main() { //演示将结构体、map、切片进行序列化 testStruct()

}

<a name="1bca3f17"></a>
### json 的反序列化
<a name="f72dd4a6-2"></a>
#### 基本介绍
1. json 反序列化是指，将json字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作。
<a name="e54fecf2-1"></a>
#### 应用案例
1. json 字符串反序列化成 struct
```go
package main
import (
    "encoding/json"
    "fmt"
)
//定义结构体
type Monster struct {
    Name string
    Age int
    Birthday string
    Salary float64
    Skill string
}
//演示将 json 字符串，反序列化成 struct
func unmarshalStruct() {
    // 说明 str 在项目开发中，是通过网络传输获取到... 获取是读取文件获取到
    str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Salary\":8000,\"Skill\":\"牛魔拳\"}"
    //定义一个 Monster 的实例
    var monster Monster
    err := json.Unmarshal([]byte(str), &monster)
    if err != nil {
        fmt.Println("str 反序列化错误 error: ", err)
    } else {
        fmt.Printf("str 反序列化后 = %v", monster)
    }
}
func main() {
    // 调用 unmarshalStruct
    unmarshalStruct()
}

json 字符串反序列化成 map ```go package main

import ( “encoding/json” “fmt” )

//演示将 json 字符串，反序列化成 map func unmarshalMap() { // 说明 str 在项目开发中，是通过网络传输获取到… 获取是读取文件获取到 str := “{\”address\”:\”火云洞\”,\”age\”:30,\”name\”:\”红孩儿\”}”

// 定义一个 map 的实例
var a map[string]interface{}
// a = make(map[string]interface{}) 反序列化不需要 make，因为 make 操作被封装到 Unmarshal 中
err := json.Unmarshal([]byte(str), &a)
if err != nil {
    fmt.Println("a 反序列化错误 error: ", err)
} else {
    fmt.Printf("a 反序列化后 = %v", a)
}

}

func main() { //调用函数 unmarshalMap unmarshalMap() }


3. json 字符串反序列化成 slice
```go
package main
import (
    "encoding/json"
    "fmt"
)
//演示将 json 字符串，反序列化成 slice
func unmarshalSlice() {
    // 说明 str 在项目开发中，是通过网络传输获取到... 获取是读取文件获取到
    str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"Jack\"},{\"address\":\"墨西哥\",\"age\":\"20\",\"name\":\"Tom\"}]"
    //定义一个 slice
    var slice []map[string]interface{}
    err := json.Unmarshal([]byte(str), &slice)
    if err != nil {
        fmt.Println("slice 反序列化错误 error: ", err)
    } else {
        fmt.Printf("slice 反序列化后 = %v", slice)
    }
}
func main() {
    //调用函数 unmarshalSlice()
    unmarshalSlice()
}

对上面代码的小结说明
- 在反序列化一个 json 字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致。
- 如果 json 字符串是通过程序获取到的，则不需要再对双引号进行转义处理。

课程来源

尚硅谷 Go 核心编程

第十四章 文件操作

文件操作

文件的基本介绍

常用的文件操作函数和方法

判断文件是否存在

文件编程应用实例

拷贝文件

命令行参数

命令行参数一

需求

基本介绍

案例说明

json

json 的基本介绍

json 数据格式说明

json 数据在线解析

json 的序列化

介绍

应用案例

课程来源

第十四章文件操作