go学习之文件操作与命令行参数

文章目录

• • 一、文件操作
  • • 1.基本介绍
    • 2.常用文件操作函数和方法
    • 3.关于文件操作应用实例
    • 4.写文件操作应用实例（创建文件并写入文件）
    • • 1）基本介绍
      • 2）基本应用实例-方式一
    • 5.判断文件是否存在
    • 6.统计英文、数字、空格和其他字符数量
  • 二、命令行参数
  • • 1.使用os.Args对参数进行解析
    • 2.flag包解析命令行参数

一、文件操作

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表示换行
	//写入时，使用带缓存的*writer
	writer := 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 表示换行
	//写入时，使用带缓存的*writer
	writer := 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 表示换行
	//写入时，使用带缓存的*writer
	writer := 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 表示换行
	//写入时，使用带缓存的*writer
	writer := 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，获取到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:/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
	//创建一个Reder
	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 <= '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 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)

}

测试结果

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