go-文件

go-文件

基本介绍

1. 文件在程序中是以流的形式来操作的
   1. 流：数据在数据源（文件）和程序（内存）之间的经历的路径
   2. 输入流（读文件）：数据从数据源（文件）到程序（内存）的路径
   3. 输出流（写文件）：数据从程序（内存）到数据源（文件的路径）
2. os.File 封装所有文件相关的操作，File是一个结构体

开关文件

1. 打开一个文件进行读操作

   func Open(name string) (file *File, err error)

   Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。

2. 关闭一个文件

   func (f *File) Close() error

   Close关闭文件f，使文件不能用于读写。它返回可能出现的错误。

func main() {
	file, err := os.Open("src/go_code/Study_go/Study_go_twelve/demo01/text/a.txt")
	if err == nil {
		fmt.Printf("file: %v\n", file)  // file: &{0xc000130120}  引用类型
		var b []byte = make([]byte, 20) // 分配大小
		n, err2 := file.Read(b)
		if err2 == nil {
			fmt.Printf("n: %v\n", n)    // n: 8
			fmt.Printf("byte: %s\n", b) // byte: hello go
		}
	} else {
		fmt.Printf("err: %v\n", err)
	}
	// 关闭文件
	file.Close()
}

读文件

带缓冲Reader读文件

func main() {
	file, err := os.Open("src/go_code/Study_go/Study_go_twelve/demo02/file/file01.txt")
	// 当函数退出时，要及时的关闭file
	defer file.Close()
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
	// 创建一个 *Reader 带缓冲的
	// 默认缓冲区为4096
	reader := bufio.NewReader(file)
	// 循环读取文件内容
	for true {
		str, err3 := reader.ReadString('\n') // 读到换行就结束
		fmt.Printf("str: %v", str)
		if err3 == io.EOF {
			break
		}
		// str: hello world
		// str: hello go
		// str: 你好语言
	}
	fmt.Println("")

}

一次性读文件

func main() {
	filePath := "src/go_code/Study_go/Study_go_twelve/demo02/file/file01.txt"
	b, err := ioutil.ReadFile(filePath)
	if err == nil {
		fmt.Printf("b: %s\n", b)
	}
	fmt.Printf("b: %v\n", string(b))
}

创建并写入四种方式

案例1

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

func main() {
	// 案例一：
	filePath := "src/go_code/Study_go/Study_go_twelve/demo04/file/new.txt"
	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0666)
	defer file.Close()
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString("hello go \n")
	}
	// 因为writer是带缓存的（写入缓存中），因此需要调用刷新方法，真正写入文件
	writer.Flush()

	b, err2 := ioutil.ReadFile(filePath)
	if err2 != nil {
		return
	}
	fmt.Printf("b: %s\n", string(b))
}

案例2

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

func main() {
	// 案例二：
	filePath := "src/go_code/Study_go/Study_go_twelve/demo04/file/new.txt"
	file, err := os.OpenFile(filePath, os.O_WRONLY, 0777)
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString("hello world\n")
	}
	writer.Flush()
}

案例3

func main() {
	// 案例三：
	filePath := "src/go_code/Study_go/Study_go_twelve/demo04/file/new.txt"
	file, err := os.OpenFile(filePath, os.O_APPEND|os.O_RDWR, 0777)
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString("hello go\n")
	}
	writer.Flush()
}

案例4

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

func main() {
	// 案例四：
	filePath := "src/go_code/Study_go/Study_go_twelve/demo04/file/new.txt"
	file, err := os.OpenFile(filePath, os.O_APPEND|os.O_RDWR, 0777)
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	defer file.Close()
	// 先读
	r := bufio.NewReader(file)
	w := bufio.NewWriter(file)
	rw := bufio.NewReadWriter(r, w)
	for {
		s, err2 := rw.ReadString('\n')
		if err2 == io.EOF {
			break
		}
		fmt.Printf("s: %v", s)
	}
	// 后写
	for i := 0; i < 3; i++ {
		rw.WriteString("hello 大连\n")
	}
	rw.Writer.Flush()
}

案例5

func main() {
	readFilePath := "src/go_code/Study_go/Study_go_twelve/demo08/file/a.txt"
	writeFilePath := "src/go_code/Study_go/Study_go_twelve/demo08/file/b.txt"
	b, err := ioutil.ReadFile(readFilePath)
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	err2 := ioutil.WriteFile(writeFilePath, b, 0777)
	if err2 != nil {
		fmt.Printf("err2: %v\n", err2)
	}
}

判断文件或目录

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

1. 若返回的错误为nil，说明文件或文件夹存在
2. 若返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
3. 若返回的错误是其他类型，则不确定是否存在

拷贝文件

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

func main() {
	srcPath := "src/go_code/Study_go/Study_go_twelve/demo09/file1/a.jpg"
	dstPath := "src/go_code/Study_go/Study_go_twelve/demo09/file2/xxx.jpg"
	srcfile, err1 := os.Open(srcPath)
	if err1 != nil {
		fmt.Printf("err1: %v\n", err1)
		return
	}
	defer srcfile.Close()
	reader := bufio.NewReader(srcfile)
	dstfile, err2 := os.OpenFile(dstPath, os.O_CREATE|os.O_WRONLY, 0777)
	if err2 != nil {
		fmt.Printf("err2: %v\n", err2)
		return
	}
	defer dstfile.Close()
	writer := bufio.NewWriter(dstfile)

	_, err := io.Copy(writer, reader)
	if err != nil {
		fmt.Println("copy failure")
	} else {
		fmt.Println("copy success")
	}

}

统计文件内容

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

type CharCount struct {
	ChNum    int
	SpaceNum int
	NumNum   int
	OtherNum int
}

func main() {
	filePath := "src/go_code/Study_go/Study_go_twelve/demo10/file/a.txt"
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}
	defer file.Close()
	reader := bufio.NewReader(file)
	var charCount CharCount
	for {
		b, err2 := reader.ReadBytes('\n')
		if err2 == io.EOF {
			break
		}
		for _, v := range b {
			switch {
			case v >= 'a' && v < 'z':
				charCount.ChNum++
			case v >= 'A' && v <= 'Z':
				charCount.ChNum++
			case v >= '0' && v <= '9':
				charCount.NumNum++
			case v == ' ' || v == '\t':
				charCount.SpaceNum++
			default:
				charCount.OtherNum++
			}
		}
	}
	fmt.Printf("charCount: %v\n", charCount)
	fmt.Printf("char: %v\nspace: %v\nnum: %v\nother: %v\n",
		charCount.ChNum, charCount.SpaceNum, charCount.NumNum, charCount.OtherNum)
}