【Golang】九、基础篇 --- 文件操作

文件读取

（1）缓冲区读取

var filePath string = "文件路径"
func main(){
	// 1. 打开文件
	f, _ := os.Open(filePath)
	defer f.Close()
	// 2. 缓冲读取文件
	reader := bufio.NewReader(f)
	for {
		// ReadString('\n')  表示读到\n结束读取
		str, err := reader.ReadString('\n')
		// io.EOF 表示文件末尾
		if err == io.EOF {
			break
		}
		fmt.Println(str)
	}
}

（2）全部读取

func main(){
	// ReadFile 封装了打开文件和读取文件操作
	// 会将文件内容一次读取出来
	b,err := ioutil.ReadFile(filePath)
	fmt.Println(string(b), err)
}

文件写入

（1）文件操作模式分类

函数OpenFile控制打开文件的模式权限

func OpenFile(name string, flag int, perm FileMode)

1. 参数1：文件路径
2. 参数2：文件打开的模式（读 or 写 or 追加 or 创建 … 等操作）
3. 参数3：权限控制（r：4，w：2，x：1），只在unix和linux下有效

参数详情参考如下模式

1. 参数2可选模式

   const (
       O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
       O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
       O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
       O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
       O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
       O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
       O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
       O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
   )
   

2. 参数3可选参数

   const (
       // 单字符是被String方法用于格式化的属性缩写。
       ModeDir        FileMode = 1 << (32 - 1 - iota) // d: 目录
       ModeAppend                                     // a: 只能写入，且只能写入到末尾
       ModeExclusive                                  // l: 用于执行
       ModeTemporary                                  // T: 临时文件（非备份文件）
       ModeSymlink                                    // L: 符号链接（不是快捷方式文件）
       ModeDevice                                     // D: 设备
       ModeNamedPipe                                  // p: 命名管道（FIFO）
       ModeSocket                                     // S: Unix域socket
       ModeSetuid                                     // u: 表示文件具有其创建者用户id权限
       ModeSetgid                                     // g: 表示文件具有其创建者组id的权限
       ModeCharDevice                                 // c: 字符设备，需已设置ModeDevice
       ModeSticky                                     // t: 只有root/创建者能删除/移动文件
       // 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
       ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
       ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
   )
   

（2）文件写入操作模版（带缓冲区）

func main() {
	// 打开文件
	file, err := os.OpenFile(filePath2, os.O_WRONLY | os.O_CREATE | os.O_TRUNC, 0777)
	// defer关闭文件
	defer file.Close()
	// 创建写入缓冲区
	writer := bufio.NewWriter(wFile)
	// 写入缓冲区
	writer.WriteString("C俄式测试测试")
	// 冲洗缓冲区内容到文件
	writer.Flush()
}

文件读写案例

（1）将文件1内容写入到文件2

func WAB() {
	// test.txt 写入到 text2.txt

	// 读取方式1:缓冲读取
	file1, _ := os.Open(filePath)
	read := bufio.NewReader(file1)
	allStr := ""
	for {
		str, err := read.ReadString('*')
		if err != nil && err == io.EOF {
			break
		}
		allStr = allStr + str
	}

	// 读取方式2:全部读取
	// file1_copy, _ := ioutil.ReadFile(filePath)
	// allStr = allStr + string(file1_copy)

	// 写入
	file2, err := os.OpenFile(filePath2, os.O_APPEND | os.O_WRONLY, os.ModeAppend)
	if err != nil {
		return
	}
	writer := bufio.NewWriter(file2)
	writer.WriteString(allStr)
	writer.Flush()
	// 不带缓冲区的写法：file2.WriteString(allStr)
	fmt.Println("成功")
}

（2）判断文件是否存在

1. 使用os.Stat来判断文件是否存在
2. 文件存在则err为空
3. 返回错误类型使用os.IsNotExist判断为true则文件不存在，其他判断同理

func fileOperation(filename string) bool {
	_, err := os.Stat(filePath3)
	success := false
	if os.IsExist(err) {
		fmt.Println("文件存在")
	} else if os.IsNotExist(err) {
		fmt.Println("文件不存在")
	} else if os.IsPermission(err) {
		fmt.Println("权限被拒绝")
	} else if os.IsTimeout(err) {
		fmt.Println("读取超时")
	} else if err == nil {
		success = true
		fmt.Println("其他")
	}
	return success
}

（3）拷贝文件

io.Copy(Writer, reader)
参数1：写缓冲区
参数2：读缓冲区

// dstPath：拷贝新文件的文件路径
// srcPath：被拷贝的文件路径
func fileCopy(dstPath string, srcPath string) {
	srcFile, err := os.Open(srcPath)
	defer srcFile.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	reader := bufio.NewReader(srcFile)

	dstFile, err := os.OpenFile(dstPath, os.O_CREATE | os.O_RDWR, 0777)
	defer  dstFile.Close()
	if err != nil {
		fmt.Println("创建文件失败")
		return
	}
	Writer := bufio.NewWriter(dstFile)

	io.Copy(Writer, reader)
}

（4）统计文本的特殊字符数量

使用到正则匹配regexp.MustCompile()

type CharCount struct {
	EngCount int
	NumCount int
	SpaceCount int
	OtherCount int
}
func (receiver CharCount) String() string {
	str, _ := json.Marshal(receiver)
	return string(str)
}
func ReadAll(filePath string) {
	// 初始化结构体
	var count CharCount
	file, err := os.Open(filePath)
	if err != nil {
		return
	}
	read := bufio.NewReader(file)
	for {
		str, err := read.ReadString('\n')
		if err != nil && err == io.EOF{
			break
		}
		// 数字
		regNd := regexp.MustCompile(`[\d]`)
		count.NumCount = count.NumCount + len(regNd.FindAll([]byte(str), -1))

		// 英文
		regEng := regexp.MustCompile(`[a-z | A-Z]`)
		count.EngCount = count.EngCount + len(regEng.FindAll([]byte(str), -1))

		// 空格
		regS := regexp.MustCompile(`[\s]`)
		count.SpaceCount = count.SpaceCount + len(regS.FindAll([]byte(str), -1))

		// 其他字符
		regO := regexp.MustCompile(`[:punct:]`)
		count.OtherCount = count.OtherCount + len(regO.FindAll([]byte(str), -1))

	}
	fmt.Println(count)
}