第十四章文件操作-阿里云开发者社区

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字符串是通过程序获取到的，则不需要再对 “ 转义处理。

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

第十四章文件操作

1.文件的基本操作

2. 打开文件和关闭文件

3.读文件操作应用实例

4 基本应用实例

5. 拷贝文件

6.命令行参数

基本介绍

flag包来解析命令行参数

热门文章

最新文章

相关电子书

相关实验场景

第十四章 文件操作

1.文件的基本操作

2. 打开文件和关闭文件

3.读文件操作应用实例

4 基本应用实例

5. 拷贝文件

6.命令行参数

基本介绍

flag包来解析命令行参数

热门文章

最新文章

相关电子书

相关实验场景

第十四章文件操作