golang学习笔记013--文件操作

1.基本概念

● 输入流和输出流
  ○ 文件在程序中是以流的形式来操作的
  ○ 流：数据在数据源（文件）和程序（内存）之间经历的路径
● os.File封装所有文件相关操作，File是一个结构体

2. 打开文件和关闭文件

（1）使用的方法

（2）代码演示

	package main
	
	import (
		"fmt"
		"os"
	)
	
	func main(){
		//file的叫法：file对象，file指针，file文件句柄
		//打开文件
		file , err :=os.Open("d:/test.txt")
		if err != nil {
			fmt.Println("err:",err)
		}
		//读取文件
		fmt.Printf("file=%v",file)//file=&{0xc0000d0780} 说明file存的是地址
		//关闭文件
		err = file.Close()
		if err != nil{
			fmt.Println("close err:",err)
		}
	}

3.读取文件

（1）使用缓冲区的方式

	package main
	
	import (
		"fmt"
		"os"
		"bufio"
		"io"
	)
	
	func main(){//file的叫法：file对象，file指针，file文件句柄
		//打开文件
		file , err :=os.Open("d:/test.txt")
		if err != nil {
			fmt.Println("err:",err)
		}
		//当函数退出时，要及时关闭file
		defer file.Close()
	
		//创建一个 *Reader 带缓冲  默认大小为4096
		reader := bufio.NewReader(file)
		//循环读取文件内容
		for{
			str,err := reader.ReadString('\n')//读到一个换行就结束
			if err == io.EOF{//io.EOF表示文件的末尾
				break
			}
			//输出内容
			fmt.Print(str)
		}
		fmt.Println("文件读取结束。。。")
		// abc
		// 中国666
		// 文件读取结束。。。
	
	}

（2）使用ioutil一次读取

使用ioutil一次性将整个文件读入到内存，这种方式适用于文件不大的情况

	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) //[97 98 99 13 10 228 184 173 229 155 189 54 54 54 13 10]
		fmt.Println()
		fmt.Printf("%v", string(content))
		// abc
		// 中国666
	}

4.写入文件

(1)os.OpenFile函数

● name string：文件路径
● flag int：文件打开模式，可以组合

● perm FileMode：权限控制，window不起作用

(2)示例创建文件并写入

创建一个文件，写入内容 5句 hello world

	package main
	
	import (
		"bufio"
		"fmt"
		"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()
	}

(3)示例覆盖并写入

打开一个存在的文件，将原来的内容覆盖成新的内容，10局 你好生活

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

(4)示例追加内容

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

	package main
	
	import (
		"bufio"
		"fmt"
		"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()
		str := "ABC,ENGLISH!\r\n" // \r\n 表示换行
		//写入时，使用带缓存的 *Writer
		writer := bufio.NewWriter(file)
		for i := 0; i < 10; i++ {
			writer.WriteString(str)
		}
		writer.Flush()
	
	}

(5)示例读和写

打开一个文件，将原来的内容读取显示在终端，并追加5句 hello北京

	package main
	
	import (
		"bufio"
		"fmt"
		"io"
		"os"
	)
	
	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)
		}
	
		str := "hello北京!\r\n" // \r\n 表示换行
		//写入时，使用带缓存的 *Writer
		writer := bufio.NewWriter(file)
		for i := 0; i < 5; i++ {
			writer.WriteString(str)
		}
	
		writer.Flush()
	
	}

(6)将一个文件内容写入到另外一个文件

注：这两个文件已经存在了

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

覆盖kkk.txt，将abc.txt内容写入

5.判断文件是否存在

golang判断文件或文件夹是否存在的方法为os.Stat()函数，根据返回值进行判断
● 如果返回值的错误为nil，说明文件或文件夹存在
● 如果返回值的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
● 如果返回的错误类型为其它类型，则不确定是否存在
自己写个函数，如果返回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
	}

6.文件编程实例

6.1 拷贝文件

	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.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:/电脑壁纸.jpg 文件拷贝到 f:/abc.jpg
	
		//调用CopyFile 完成文件拷贝
		srcFile := "d:/电脑壁纸.jpg"
		dstFile := "f:/abc.jpg"
		_, err := CopyFile(dstFile, srcFile)
		if err == nil {
			fmt.Printf("拷贝完成\n")
		} else {
			fmt.Printf("拷贝错误 err=%v\n", err)
		}
	
	}

6.2统计英文、数字，空格和其它字符数量

	package main
	
	import (
		"bufio"
		"fmt"
		"io"
		"os"
	)
	
	//定义一个结构体，用于保存统计结果
	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
			//str1 := []rune(str)
			//遍历 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)
	
	}

7.命令行参数

如何获获取命令行输入的各种参数，使用os.Args
os.Args是一个string切片，用来存储所有的命令行参数

7.1 os.Args获取参数

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

该方法对参数顺序有严格要求，不是很方便

7.2 flag包来解析命令行

参数顺序可以随意
比如：获取test.exe -u root -pwd root -h 192.168.0.1 -port 3306

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

8.序列化

	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()//演示对基本数据类型的序列化
	}

monster序列化后={"monster_name":"牛魔王","monster_age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}
a map 序列化后={"address":"洪崖洞","age":30,"name":"红孩儿"}
slice 序列化后=[{"address":"北京","age":"7","name":"jack"},{"address":["墨西哥","夏威夷"],"age":"20","name":"tom"}]
num1 序列化后=2345.67

9.反序列化

	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]]