第十四章文件操作

最新推荐文章于 2024-05-06 19:22:35 发布

2019ab

最新推荐文章于 2024-05-06 19:22:35 发布

阅读量449

点赞数

分类专栏： GO 文章标签： golang 后端

本文链接：https://blog.csdn.net/ab15176142633/article/details/128267113

版权

GO 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.文件的基本操作

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

输入流和输出流…
在这里插入图片描述
os.File封装所有文件相关操作，File是一个结构体

在这里插入图片描述
总结：后面我们操作文件，会经常使用到os.File结构体

2. 打开文件和关闭文件

使用的方法和函数
在这里插入图片描述

演示

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

3.读文件操作应用实例

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

package main 
import (
	"fmt"
	"os"
	"bufio"
	"io"
)
func main(){
	// 打开文件
	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表示文件的末尾
			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",content) // []byte
	fmt.Printf("%v",string(content)) // []byte
	//我们没有显示的Open文件，因此也不需要显示的Close文件
	// 因为，文件的Open和Close被封装到ReadFile函数内部
	
}

4 基本应用实例

创建一个新文件，写入内容5句 “hello,Gardon”
代码实现：

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

编写一个程序，将一个文件的内容，写入到另外一个文件，注：这两个文件已经存在了
说明：使用ioutil.ReadFile/ioutil.WriteFile完成写文件的任务

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

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. 如果返回的错误为其他类型，则不确定是否存在

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
}

5. 拷贝文件

说明：将一张图片 /电影/mp3拷贝到另一个文件 e:/abc.jpg io包
func Copy(dst Writer,src Reader)(written int64,err error)
注意：copy函数是io包提供的
代码实现：

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

// 编写一个函数，接受两个文件路径  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)
	}
}

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

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

// 定义一个结构体，用于保存统计结果
type CharCount struct{
	ChCount int // 记录英文个数
	NumCount int // 记录数字的个数
	SpaceCount int // 记录空格的个数
	OtherCount int // 记录其他字符的个数
}

func main(){
	// 思路：打开一个文件，创建一个Reader
	// 每读取一行，就去统计该行有多少个 英文，数字，空格和其他字符
	// 然后将结果保存到结构体
	fileName := "d:/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
		str = []run(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++
				default :
					count.OtherCount++
			}
		}
	}
	
	// 输出统计的结果看看是否正确
	fmt.Printf("字符的个数为=%v 数字的个数为=%v 空格的个数为=%v 其他字符个数=%v",count.ChCount,count.NumCount,count.SpaceCount,count.OtherCount)
}

6.命令行参数

看一个需求
我们希望能获取到命令行输入的各种参数，该如何处理？如图：=》命令行参数
在这里插入图片描述

基本介绍

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

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

flag包来解析命令行参数

说明：前面的方式比较原生的方式，对解析参数不是特别方便，特别是带有制定参数形式的命令行。
比如：cmd>main.exe -fc:/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","loaclhost","主机名，默认为localhost")
  flag.IntVar(&port,"port",3306,"端口号，默认为3306")
  // 这里有一个非常重要的操作，转换，必须调用该方法
  flag.Parse()
  // 输出结果
  fmt.Printf("user=%v pwd=%v host=%v port=%v",user,pwd,host,port)
}

在这里插入图片描述

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 
}

// 演示将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\n",monster)
}

func main(){
	unmarshalStruct()
}

总结说明：

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

感谢大家观看，我们下次见

2019ab

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第十四章文件操作

请写一段代码，可以获取命令行各个参数fmt . Println("命令行的参数有" , len(os . Args)) // 遍历os.Args切片，就可以得到所有的命令行输入参数值 for i , v := range os . Args {
复制链接

扫一扫