go 文件操作

文件概念

文件，对我们并不陌生，文件是数据源（保存数据的地方）的一种，比如txt文件，excel文件… 都是文件。文件最主要的作用就是保存数据，可以是图片，视频，音频…

输入流和输出流

文件在程序中是以流的形式来操作的

流：数据在数据源（文件）和程序（内存）之间经历的路径
输入流： 数据从数据源（文件）到程序（内存）的路径
输出流： 数据从程序（内存）到数据源（文件）的路径

• os.File封装所有文件相关操作，File是一个结构体
  https://studygolang.com/pkgdoc

打开文件和关闭文件

• 使用的函数和方法
  fun Open

func Open(name string) (file *File, err error)

Open打开一个文件用于读取，如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是 *PathError

func (*File) Close

func (f *File) Close() error

Close关闭文件f，使文件不能用于读写，它返回可能出现的错误

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)
	}
	fmt.Printf("file=%v", file)
	//关闭文件
	err = file.Close()
	if err != nil {
		fmt.Println("close file err=", err)
	}
}

读文件操作

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

package main

import (
	"bufio"
	"fmt"
	"io"
	"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
	defer file.Close()
	//创建一个 *Reader, 是带缓冲的
	/*
	const (
		defaultBufSize = 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）

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\n", content) // []bype
	fmt.Printf("%v\n", string(content)) //文本显示
	//没有显式的Open文件，因此也不需要显式的Close文件
	//文件的Open和Close被封装到ReadFile函数内部
}

写文件操作

os.OpenFile函数

func OpenFile

func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError

• flag int
  Constants

const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)

用于包装底层系统的参数用于Open函数，不是所有的flag都能在特定系统里使用的

• perm FileMode
  权限控制

r -> 4
w -> 2
x -> 1

1. 创建一个新文件，写入内容5句 “hello, world”

package main

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

func main() {
	//创建一个新文件，写入内容5句 "hello, world"
	//打开文件 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", err)
		return
	}
	defer file.Close()
	str := "hello, world\n"
	//写入时，使用带缓冲的 *Writer
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}
	//因为writer是带缓冲，因此在调用WriterString方法时
	//内容是先写入到缓冲的，所以需要调用Flush方法，将缓冲的数据
	//真正写入到文件中，否则文件中没有数据！！！
	writer.Flush()
}

2. 打开一个存在的文件中，将原来的内容覆盖成新的内容10句 “你好，五行哥!”

package main

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

func main() {
	//打开文件 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
	}
	defer file.Close()
	str := "你好，五行哥！\r\n"
	//写入时，使用带缓冲的 *Writer
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}
	writer.Flush()
}

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

package main

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

func main() {
	//打开文件 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
	}
	defer file.Close()
	str := "ABC,ENGLISH!\r\n"
	//写入时，使用带缓冲的 *Writer
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}
	writer.Flush()
}

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

package main

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

func main() {
	//打开文件 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
	}
	defer file.Close()
	//先读取原来文件内容，并显示在终端
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF {//如果读取到文件的末尾
			break
		}
		//显示到终端
		fmt.Print(str)
	}
	str := "hello,北京!\r\n"
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}
	writer.Flush()
}

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

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {
	//将d:/abc.txt 文件内容导入到 e:/kkk.txt
	//1.首先将 d:/abc.txt 内容读取到内存
	//2. 将读取到的内容写入 e:/kkk.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
	}
	err = ioutil.WriteFile(file2Path, data, 0666)
	if err != nil {
		fmt.Printf("write file error=%v\n", err)
	}
}

判断文件是否存在

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

package main

import (
	"fmt"
	"os"
)

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
}
func main() {
	res, err := PathExists("d:/abc.txt")
	fmt.Println(res, err)
}

拷贝文件

将一个文件（图片/视频/音频）拷贝到另一个文件

package main

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

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()
	reader := bufio.NewReader(srcFile)
	dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("open file err=%v\n", err)
		return
	}
	writer := bufio.NewWriter(dstFile)
	defer dstFile.Close()
	return io.Copy(writer, reader)
}
func main() {
	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 (
	"bufio"
	"fmt"
	"io"
	"os"
)

type CharCount struct {
	ChCount int
	NumCount int
	SpaceCount int
	OtherCount int
}

func main() {
	fileName := "d:/abc.txt"
	file, err := os.Open(fileName)
	if err != nil {
		fmt.Printf("open file err=%v\n", err)
		return
	}
	defer file.Close()
	var count CharCount
	//创建一个Reader
	reader := bufio.NewReader(file)
	for  {
		str, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}
		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\n", count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}

命令行参数

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

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("命令行参数有", len(os.Args))
	for i, v := range os.Args {
		fmt.Printf("args[%v]=%v\n", i, v)
	}
}

flag包用来解析命令行参数

go设计者提供了flag包，方便解析命令行参数，而且参数顺序可以随意

package main

import (
	"flag"
	"fmt"
)

func main() {
	var user string
	var pwd string
	var host string
	var port  int
	flag.StringVar(&user, "u", "", "用户名，默认为空")
	flag.StringVar(&pwd, "p", "", "密码，默认为空")
	flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
	flag.IntVar(&port, "port", 3306, "端口号，默认为3306")
	//这里有一个非常重要的操作，转换， 必须调用该方法
	//Parse从参数os.Args[1:]中解析命令行标签。 这个方法调用时间点必须在FlagSet的所有标签都定义之后，程序访问这些标签之前
	flag.Parse()
	fmt.Printf("user=%v\npwd=%v\nhost=%v\nport=%v\n", user, pwd, host, port)
}

build

go build -o test.exe main.go

运行

test.exe -h 192.168.0.1 -u root -p 123456 -port 3307

json

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

应用场景

json数据格式说明

在js语言中，一切都是对象。因此，任何的数据类型都可以通过JSON来表示，例如字符串、数字、对象、数组、map、结构体等

JSON键值对是用来保存数据的一种方式

键值对组合中的键名写在前面并用双引号""包裹，使用冒号: 分隔，然后紧接着值

[{"key1":val1, "key2":val2, "key3":val3, "key4":[val4, val5]},
{"key1":val1, "key2":val2, "key3":val3, "key4":[var4, var5]}]

{"firstName":"Json"}
{"name":"tom", "age":18, "address":["北京", "上海"]}

[{"name":"tom", "age":18, "address":["北京", "上海"]},
{"name":"mary", "age":28, "address":["广州", "深圳"]}]

json数据在线解析

https://www.json.cn/

可以验证一个json格式的数据是否正确

json的序列化

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

func Marshal(v interface{}) ([]byte, error)

• 结构体，map和切片的序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name string
	Age int
	Birthday string
	Sal float64
	Skill string
}

func testStruct()  {
	monster := Monster{
		"牛魔王",
		500,
		"2011-11-11",
		8000.0,
		"牛魔拳",
	}
	//将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()  {
	var a map[string]interface{}
	a = make(map[string]interface{})
	a["name"] = "红孩儿"
	a["age"] = 30
	a["address"] = "洪崖洞"
	data, err := json.Marshal(a)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
	}
	fmt.Printf("a map 序列化后=%v\n", string(data))
}
//切片进行序列化
func testSlice()  {
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "jack"
	m1["age"] = "7"
	m1["address"] = "北京"
	slice = append(slice, m1)
	var m2 map[string]interface{}
	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
	data, err := json.Marshal(num1)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
	}
	fmt.Printf("num1 序列化后=%v\n", string(data))
}
func main() {
	testStruct()
	testMap()
	testSlice()
	testFloat64()
}

• 注意事项
  对于结构体的序列化，如果希望序列化后的key的名字，又重新制定，可以给struct指定一个tag标签

type Monster struct {
	Name string `json:"monster_name"` //反射机制
	Age int `json:"monster_age"`
	Birthday string `json:"birthday"`
	Sal float64 `json:"sal"`
	Skill string `json:"skill"`
}

json的反序列化

json反序列化是指，将json字符串反序列化成对应的数据类型（比如结构体，map，切片）的操作

func Unmarshal(data []byte, v interface{}) error

package main

import (
	"encoding/json"
	"fmt"
)

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\":\"牛魔拳\"}"
	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\":\"红孩儿\"}"
	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\"}]"
	var slice []map[string]interface{}
	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字符串是通过程序获取到的，则不需要再对 " 转义处理