文件操作

文件的基本介绍

文件的概念：文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的word 文档,txt 文件,excel 文件…都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声音…
输入流和输出流：文件在程序中是以流的形式来操作的
流：数据在数据源（文件）和程序（内存）之间经历的路径
os.File 封装所有文件相关操作，File 是一个结构体，后面我们操作文件，会经常使用到 os.File 结构体.

打开文件和关闭文件

使用的函数和方法

func Open(name string) (*File, error)
func (f *File) Close() error

案例演示

package main
import (
    "fmt"
    "os" 
)
func main() {
    //打开文件
    //概念说明: file 的叫法
    //1. file 叫 file对象
    //2. file 叫 file指针
    //3. file 叫 file 文件句柄
    file , err := os.Open("C:/Users/liwenchang/Desktop/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }
    //输出下文件，看看文件是什么, 看出file 就是一个指针 *File
    fmt.Printf("file=%v", file)//file=&{0xc00007e780}
    //关闭文件
    err = file.Close()
    if err != nil {
        fmt.Println("close file err=", err)
    }
}

读文件操作应用实例

读取文件的内容并显示在终端(带缓冲区的方式)，使用 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表示文件的末尾
         fmt.Printf("err: %v\n", err)
         break
     }
     //输出内容
     fmt.Printf(str)
 }
 fmt.Println("文件读取结束...")
}

读取文件的内容并显示在终端(使用 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完成写文件的任务
```go func OpenFile(name string, flag int, perm FileMode) (file File, err error) OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是PathError。

第一个参数：文件地址第二个参数：文件打开模式（可以组合） const{ O_RDONLY int = syscall.O_RDONLY//只模式打开文件 O_WRDONLY int = syscall.O_WRDONLY//只写模式打开文件 O_RDWR int = syscall.O_RDWR//读写模式打开文件 O_APPEND int = syscall.O_APPEND//写操作时将数据附加到文件尾部 O_CREATE int = syscall.O_CREATE//如果不存在将创建一个新文件 O_EXCL int = syscall.O_EXCL//和O_CREATE配合使用，文件必须不存在 O_SYNC int = syscall.O_SYNC//打开文件用于同步I/O O_TRUNC int = syscall.O_TRUNC//如果可能，打开时清空文件 } 第三个参数：权限控制 0 表示八进制 4 r表示可读 2 w表示可写 1 x表示可执行

-rwxrwxrwx 第1位：文件属性，一般常用的是”-“，表示是普通文件；”d”表示是一个目录。第2～4位：文件所有者的权限rwx (可读/可写/可执行)。第5～7位：文件所属用户组的权限rwx (可读/可写/可执行)。第8～10位：其他人的权限rwx (可读/可写/可执行)

在golang中，可以使用os.FileMode(perm).String()来查看权限标识： os.FileMode(0777).String() //返回 -rwxrwxrwx
os.FileMode(0666).String() //返回 -rw-rw-rw- os.FileMode(0644).String() //返回 -rw-r—r—


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

打开一个存在的文件中，将原来的内容覆盖成新的内容 5 句 “你好，世界!” ```go 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 < 5; i++ {
    writer.WriteString(str)
}
//因为writer是带缓存，因此在调用WriterString方法时，其实
//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中， 否则文件中会没有数据!!!
writer.Flush()

}


3. 打开一个存在的文件，在原来的内容追加内容“~~~”
```go
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_APPEND, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }
    //及时关闭file句柄
    defer file.Close()
    str := "~~~\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用WriterString方法时，其实
    //内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
}

打开一个存在的文件，将原来的内容读出显示在终端，并且追加 5 句”hello,北京!” ```go 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()

}

<a name="kq3Kp"></a>
### 使用 ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务
将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了
```go
package main
import (
    "fmt"
    "io/ioutil" 
)
func main() {
    //将d:/abc.txt 文件内容导入到  e:/kkk.txt
    //1. 首先将  d:/abc.txt 内容读取到内存
    file1Path := "d:/abc.txt" 
    file2Path := "e:/kkk.txt" 
    data, err := ioutil.ReadFile(file1Path)
    if err != nil {
        //说明读取文件有错误
        fmt.Printf("read file err=%v\n", err)
        return
    }
    //2. 将读取到的内容写入 e:/kkk.txt
    err = ioutil.WriteFile(file2Path, data, 0666)
    if err != nil {
        fmt.Printf("write file error=%v\n", 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 拷贝到另外一个文件使用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)
    }
}

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

思路: 打开一个文件, 创一个Reader 每读取一行，就去统计该行有多少个英文、数字、空格和其他字符然后将结果保存到一个结构体

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 的切片，用来存储所有的命令行参数

举例说明

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

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

PS E:\GoProject> go run .\src\go_code\chapter14\argsdemo\ 1 'abc'
命令行的参数有 3
args[0]=C:\Users\LIWENC~1\AppData\Local\Temp\go-build3863904466\b001\exe\argsdemo.exe
args[1]=1
args[2]=abc

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)

}

PS E:\GoProject>  .\src\go_code\chapter14\flagdemo\test.exe -u root -pwd root -h 192.168.1.1 -port 8080
user=root pwd=root host=192.168.1.1 port=8080

JSON

基本介绍

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

数据格式说明

JSON建构于两种结构：

“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组（associative array）。
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。JSON 格式中作为值的类型允许是字符串（string）、数值（number）、true 、false、null 、对象（object）或者数组（array）
序列化
json 序列化是指，将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成 json 字符串的操作 ```go package main import ( “fmt” “encoding/json” )

//定义一个结构体 type Monster struct { Name string json:"monster_name" //指定tag标签反射机制 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 标签.
<a name="cilQY"></a>
## 反序列化
json 反序列化是指，将 json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作
```go
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()
}

反序列化后 monster={牛魔王~~~ 500 2011-11-11 8000 牛魔拳} monster.Name=牛魔王~~~ 
反序列化后 a=map[address:洪崖洞 age:30 name:红孩儿~~~~~~]
反序列化后 slice=[map[address:北京 age:7 name:jack] map[address:[墨西哥 夏威夷] age:20 name:tom]]

小结：

在反序列化一个json 字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致。
如果 json 字符串是通过程序获取到的，则不需要再转义处理

Go语言核心编程

文件操作、命令行参数和JSON

文件操作

文件的基本介绍

打开文件和关闭文件

使用的函数和方法

案例演示

读文件操作应用实例

写文件操作应用实例

使用 os.OpenFile完成写文件的任务

判断文件/文件夹是否存在

文件编程应用实例

拷贝文件

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

命令行参数

基本介绍

举例说明

flag 包用来解析命令行参数

JSON

基本介绍

数据格式说明

序列化