Go中的文件操作

文件操作

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

package main

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

func main() {
	// 打开一个文件
	file, err := os.Open("/home/gocode/src/filedemo/test")
	if err != nil{
		fmt.Println("open file err=",err)
	}

	defer file.Close()  // 要及时关闭文件句柄，否则发有内存泄漏

    // 创建一个*Reader,带缓冲区的，默认的缓冲区为4096
	reader := bufio.NewReader(file)
    // 循环读取文件内容
	for{
		str, err := reader.ReadString('
')
		if err == io.EOF{  // io.EOF表示文件的末尾
			break
		}
		fmt.Print(str)
	}
	fmt.Println("文件读取结束")
}

• 一次将整个文件读取到内存中，这种方式适用于文件不大的情况，相关方法和函数（ioutil.ReadFile）

  package main
  
  import (
  	"fmt"
  	"io/ioutil"
  )
  
  
  func main() {
  	file := "/home/gocode/src/filedemo/test"
      
      // 使用ioutil.ReadFile一次性读取
      content, err := ioutil.ReadFile(file)  // 返回值是[]byte{}
  	if err != nil{
  		fmt.Println("read file err:",err)
  	}
  
  	fmt.Println(string(content))  // 需要转换成字符串显示
     
      // 我们没有显示的打开文件，所以也不需要显示的关闭
      // Open()和Close()被封装到ReadFile 函数内部
  }
  

• 写文件操作

  (1)创建一个新文件，写入内容5句“hello Gardon”

  // 写入时，使用带缓存的*Writer
  package main
  
  import (
  	"bufio"
  	"fmt"
  	"os"
  )
  
  func main() {
  	// 创建一个新文件，写入内容5句“hello Gardon”
  	filePath := "test.txt"
  	file, err := os.OpenFile(filePath,os.O_WRONLY|os.O_CREATE,0666)
  	if err != nil{
  		fmt.Println("open file err=",err)
  		return
  	}
  
  	defer file.Close()
  
  	// 写入内容5句“hello Gardon”
  	str := "hello Gardon
  "
  	// 写入时，使用带缓存的*Writer
  	writer := bufio.NewWriter(file)
  	for i:=0;i<5;i++{
  		writer.WriteString(str)
  	}
  	// 因为writer是带缓存，因此在调用WriteString方法时，其实内容是先写到缓存的
  	writer.Flush()
  }
  

  (2)打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好Christian”

  package main
  
  import (
  	"bufio"
  	"fmt"
  	"os"
  )
  
  func main() {
  	filePath := "test.txt"
  	file,err := os.OpenFile(filePath,os.O_WRONLY|os.O_TRUNC,0666)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  
  	defer file.Close()
  
  	writer := bufio.NewWriter(file)
  
  	str := "你好Christian
  "
  	for i:=0;i<10;i++{
  		writer.WriteString(str)
  	}
  	writer.Flush()
  }
  

  (3)打开一个存在的文件，在原来的内容追加内容“ABC!ENGLISH”

  package main
  
  import (
  	"bufio"
  	"fmt"
  	"os"
  )
  
  func main() {
  	filePath := "test.txt"
  	file,err := os.OpenFile(filePath,os.O_WRONLY|os.O_APPEND,0666)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  
  	defer file.Close()
  
  	writer := bufio.NewWriter(file)
  
  	str := "ABC!ENGLISH
  "
  	writer.WriteString(str)
  	writer.Flush()
  }
  

  (4)打开一个存在的文件，将原来的内容读出显示在终端，并追加5句“hello 西安”

  package main
  
  import (
  	"bufio"
  	"fmt"
  	"io"
  	"os"
  )
  
  func main() {
  	filePath := "test.txt"
  	file,err := os.OpenFile(filePath,os.O_RDWR|os.O_APPEND,0666)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  
  	defer file.Close()
  
  	reader := bufio.NewReader(file)
  	for{
  		str,err:=reader.ReadString('
  ')
  		if err == io.EOF{
  			break
  		}
  		fmt.Print(str)
  	}
  	writer := bufio.NewWriter(file)
  
  	str := "hello 西安
  "
  	for i := 0; i<5;i++{
  		writer.WriteString(str)
  	}
  	writer.Flush()
  }
  
  

  (5)将一个文件中的内容写入到另外一个文件中。(判断要写入的文件是否存在)

  package main
  
  import (
  	"fmt"
  	"io/ioutil"
  	"os"
  )
  
  // 判断文件以及文件夹是否存在
  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
  }
  
  
  func main() {
  	file1 := "test.txt"
  	file2 := "kkk.txt"
  
  	content, err := ioutil.ReadFile(file1)
  	if err != nil{
  		fmt.Printf("read file err=%v
  ",err)
  		return
  	}
  
  	b,_:= pathExists(file2)  // 判断文件是否存在，不存在则创建
  	if !b{
  		file,err := os.OpenFile(file2,os.O_RDWR|os.O_CREATE,0666)
  		if err != nil{
  			fmt.Println("create file err:",err)
  			return
  		}
  		defer file.Close()
  	}
  
  	err = ioutil.WriteFile(file2,content,0666)
  	if err != nil{
  		fmt.Println("write file error=",err)
  		return
  	}
  }
  

• 拷贝文件

  package main
  
  import (
  	"bufio"
  	"fmt"
  	"io"
  	"os"
  )
  
  func CopyFile(dstFileName, srcFileName string) (written int64,err error){
  	srcFile, err := os.Open(srcFileName)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  
  	defer srcFile.Close()
  
  	reader := bufio.NewReader(srcFile)
  
  	dstFile, err := os.OpenFile(dstFileName,os.O_RDWR|os.O_CREATE,0666)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  
  	defer dstFile.Close()
  
  	writer := bufio.NewWriter(dstFile)
  
      return io.Copy(writer,reader)  // 调用io.Copy()    
  }
  
  func main() {
  	srcFile := "kkk.txt"
  	dstFile := "kkkk.txt"
  	_, err := CopyFile(dstFile,srcFile)
  	if err != nil{
  		fmt.Println("copy err:",err)
  	}
  }
  

• 统计字符出现的次数

  // 打开一个文件，创建一个Reader,每取一行，就去统计有多少个英文，数字，空格和其他字符
  // 将结果保存在结构体中
  
  package main
  
  import (
  	"bufio"
  	"fmt"
  	"io"
  	"os"
  )
  
  type Charcount struct{
  	ChCount int
  	NumCount int
  	SpaceCount int
  	OtherCount int
  }
  
  func main() {
  	fileName := "kkk.txt"
  	file,err := os.Open(fileName)
  	if err != nil{
  		fmt.Println("open file err:",err)
  		return
  	}
  	defer file.Close()
  
  	count := Charcount{}
  
  	reader := bufio.NewReader(file)
  	for {
  		str,err := reader.ReadString('
  ')
  		if err == io.EOF{
  			break
  		}
  		for _,v:=range str{
  			switch  {
  			case v >= 'a' && v <= 'z':
  				fallthrough
  			case v >= 'A' && v <= 'Z':
  				count.ChCount += 1
  			case v == ' ' || v == '	':
  				count.SpaceCount +=1
  			case v >= '0' && v <= '9':
  				count.NumCount += 1
  			default:
  				count.OtherCount += 1
  			}
  		}
  	}
  	fmt.Println(count)
  }