一、文件操作

1.基本介绍

文件对于我们并不陌生，文件是数据源（保存数据的地方）一种，比如大家经常使用的word文件，txt文件，excel文件…都是文件。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频声音

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

• 流：数据在数据源（文件）和程序（内存）之间经历的路径

• 输入流：数据从数据源（文件）到程序（内存）的路径

• 输出流：数据从程序（内存）到数据源（文件）的路径

os.File结构体封装所有文件相关操作

2.常用文件操作函数和方法

1）打开一个文件进行操作

os.Open(name string)(*File,error)

2）关闭一个文件：

File.Close()

3）其他的函数和方法在案例提

案例演示

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

3.关于文件操作应用实例

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

package main
import ("fmt""os""io""bufio"
)
func main(){//打开文件//概念说明： file的叫法//1. file 叫file对象//1. file 叫file指针//1. file 叫file文件句柄file , err := os.Open("D:/test/test01/test.txt")if err !=nil {fmt.Println("open file err=",err)}//当函数退出时，要及时的关闭file/*const (defaultBufSize  =4096 //默认缓冲区4096个字节)*/defer file.Close()  //要及时关闭file句柄，否则会有内存泄露//创建一个*Read ,带缓冲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.ReaderFile一次性将文件读取到位file := "D:/test/test01/test.txt"content, err := ioutil.ReadFile(file)if err !=nil {fmt.Println("read file err=%v",err)}//把读取到的内容显示到终端fmt.Printf("%v",string(content)) //[]byte//因为我们没有显示的open文件，因此也不需要显示的close文件//因为。文件Open和Close背封装到ReadFile函数内部}

注意：这种只适合文件不太大的情况使用

4.写文件操作应用实例（创建文件并写入文件）

1）基本介绍

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

说明：os.OpenFile是一个更一般性的文件打开函数，它会使用指定的选项（如O_RDONLY）、指定的模式(如0666等)打开指定名称的文件。如果操作成功，返回的文件对象可用于i/o如果出错，错误底层类型是*PathError.

第二个参数：文件打开模式（可以组合），第三个参数：权限控制(linux)

2）基本应用实例-方式一

（1）创建一个新文件，写入内容 5句"hello Gardon"

package main
import ("fmt""os""bufio"
)
func main(){//创建一个新文件，写入内容 5句"hello Gardon"//1.打开一个文件 "D:/test/test01/test.txt"filePath := "D:/test/test01/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}//及时关闭file句柄，防止内存泄露defer file.Close()//准备写入6句话str := "hello Gardon\r\n"  // \r\n表示换行//写入时，使用带缓存的*writerwriter := bufio.NewWriter(file)for i := 0; i < 5; i++ {writer.WriteString(str)}//因为writer是带缓存的，因此在调用WriterString方法时，其实内存是先写入缓存的//所以需要调用Flush()方法，将缓存的数据//真正写入到文件中，否则文件中会没有数据writer.Flush()

（2）打开一个存在的文件中，将原来的内容覆盖成新的内容10句 “你好,爸爸"

package main
import ("fmt""os""bufio"
)
func main(){//打开一个存在的文件中，将原来的内容覆盖成新的内容10句 “你好,爸爸"//1.打开一个文件 "D:/test/test01/test.txt"filePath := "D:/test/test01/abc.txt"file, err := os.OpenFile(filePath,os.O_WRONLY | os.O_TRUNC,0666)if err != nil {fmt.Printf("open file err=%v",err)return}//及时关闭file句柄，防止内存泄露defer file.Close()//准备写入10句话:你好,爸爸str := "你好,爸爸!\r\n"  // \n 表示换行//写入时，使用带缓存的*writerwriter := bufio.NewWriter(file)for i := 0; i < 10; i++ {writer.WriteString(str)}//因为writer是带缓存的，因此在调用WriterString方法时，其实内存是先写入缓存的//所以需要调用Flush()方法，将缓存的数据//真正写入到文件中，否则文件中会没有数据writer.Flush()
}

（3）打开一个存在的文件，在原来的内容追加内容“ABCI ENGLISH!”

package main
import ("fmt""os""bufio"
)
func main(){//打开一个存在的文件，在原来的内容追加内容“ABCI ENGLISH!”//1.打开一个文件 "D:/test/test01/test.txt"filePath := "D:/test/test01/abc.txt"file, err := os.OpenFile(filePath,os.O_WRONLY | os.O_APPEND,0666)if err != nil {fmt.Printf("open file err=%v",err)return}//及时关闭file句柄，防止内存泄露defer file.Close()str := "ABCI ENGLISH!\r\n"  // \n 表示换行//写入时，使用带缓存的*writerwriter := bufio.NewWriter(file)for i := 0; i < 10; i++ {writer.WriteString(str)}//因为writer是带缓存的，因此在调用WriterString方法时，其实内存是先写入缓存的//所以需要调用Flush()方法，将缓存的数据//真正写入到文件中，否则文件中会没有数据writer.Flush()
}

（4）打开一个存在的文件，将原来的内容读出显示在终端，并且追加"hello 北京"

package main
import ("fmt""os""bufio""io"
)
func main(){//打开一个存在的文件，将原来的内容读出显示在终端，并且追加"hello 北京"//1.打开一个文件 "D:/test/test01/abc.txt"//这是一个既要读又要写的操作filePath := "D:/test/test01/abc.txt"file, err := os.OpenFile(filePath,os.O_RDWR | os.O_APPEND,0666)if err != nil {fmt.Printf("open file err=%v",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"  // \n 表示换行//写入时，使用带缓存的*writerwriter := bufio.NewWriter(file)for i := 0; i < 5; i++ {writer.WriteString(str)}//因为writer是带缓存的，因此在调用WriterString方法时，其实内存是先写入缓存的//所以需要调用Flush()方法，将缓存的数据//真正写入到文件中，否则文件中会没有数据writer.Flush()
}

使用os.OpenFile(),bufio.NewWriter(),“Writer的方法WriteString完成上面的任务

3）基本应用实例-方式二

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

说明：

1）使用ioutil.ReadFile /ioutil.WriteFile 完成文件的任务

package main
import ("fmt""io/ioutil"
)
func main(){//将D:/test/test01/abc.txt文件的内容导入到D:/test/test01/kkk.txt中//1.首先将D:/test/test01/abc.txt内容读取到内存filePath :="D:/test/test01/abc.txt"filePath2 :="D:/test/test01/kkk.txt"data, err := ioutil.ReadFile(filePath)if err != nil {//说明读取文件有错误fmt.Printf("read file err=%v\n",err)return }
//2.将读取到的内容写入：D:/test/test01/kkk.txt中err = ioutil.WriteFile(filePath2,data,0666)if err != nil {fmt.Printf("write file err=%v\n",err)}//会覆盖掉写入之后的文件中的所有内容}

5.判断文件是否存在

golang判断文件或文件夹是否存在的方法是使用os.Stat()函数返回的错误进行判断：

1）如果返回的错误为nil,说明文件或文件夹存在

2）如果返回的错误类型使用so.IsNotExist()判断为true,说明文件或文件夹不存在

3）如果返回的错误为其他类型，则不确定是否存在

//自己写了一个函数
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.文件编程应用实例

拷贝文件

说明：将一张图片拷贝到另外一个目录下io包

func Copy (dst Writer,src Reader)(written int64,err error)

package main
import ("fmt""io""os""bufio"
)//自己写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string,srcFileName string)(written int64,err error){srcFile, err := os.Open(srcFileName)if err != nil {fmt.Println("open file err=%v\n",err)}//用完了需要关闭defer srcFile.Close()//通过srcFile，获取到Readerreader := 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,获取到writerwriter := bufio.NewWriter(dstFile)//用完了需要关闭defer dstFile.Close()return io.Copy(writer,reader)}
func main() {//将D:/test/dog.jpg拷贝到D:/test/test01/dog1.jpg//调用CopyFile完成文件的拷贝srcFile := "D:/test/dog.jpg"dstFile := "D:/test/test01/dog1.jpg"_, err :=CopyFile(dstFile,srcFile)if err == nil {fmt.Println("拷贝完成")} else {fmt.Printf("拷贝错误err=%v\n",err)}
}

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

说明：统计一个文件中含有的英文、数字-、空格及其它字符数量

package main
import ("fmt""os""io""bufio"
)
//定义个结构体，用于保存统计结构1
type CharCount struct {CharCount int //记录英文个数NumCount int //记录数字的个数SpaceCount int //记录空格的个数OtherCount int //记录其他字符的个数
}func main(){//思路：打开一个文件。创建一个Reader//每读取一行，就去统计该行有多少个 英文、数字、空格和其他字符//然后将它们保存到一个结构体当中
fileName := "D:/test/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//创建一个Rederreader := 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 <= 'A' :count.CharCount ++ 	case v == ' ' || v =='\t' :count.SpaceCount ++	case v >= '0' && v <='9' :count.NumCount ++ 	default :count.OtherCount ++				 }}}//输出统计的结构fmt.Printf("字符的个数=%v,数字的个数=%v,空格的个数=%v,其他字符的个数=%v",count.CharCount,count.NumCount,count.SpaceCount,count.OtherCount)
}

二、命令行参数

有一个需求

我们希望能够获取到命令行输入的各种参数，该如何处理？如下，我们执行一个可执行文件并附带一个参数

D:\myfile\GO\project\src\go_code\exec\count\main> test.exe tom c:/aa/bb/config.init 88

1.使用os.Args对参数进行解析

基本介绍

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

使用go build去编译一个可执行文件test.exe进行测试

2.flag包解析命令行参数

flag包用来解析命令行参数

说明：前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命令行

比如：cmd>main.exe -f C:/aaa.txt -p 200 -u root 这样的命令行，go设计者给我们提供了flag包，，可以方便的解析命令行参数，而且参数顺序可以随意

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

package main
import ("fmt""flag"
)
func main() {//定义几个变量，用于接收命令行的参数值var user stringvar pwd stringvar host stringvar 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)}

测试结果

将顺序打乱或者不传参数再次进行测验