Go语言编程中文件处理方法

1.文件分类

• 设备文件：屏幕（标准输出设备）、键盘（标准输入设备）
• 磁盘文件：放在存储设备上的文件，1）文本文件；2）二进制文件

2.文件常见api

【1】文件的创建和打开

新建文件可以通过如下两个方法：
Func    Create(name  string) (file *File, err Error)
根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666的文件，返回的文件对象是可读写的。
Func   NewFile(fd  uintptr, name string) *File
根据文件描述创建相应的文件，返回一个文件对象

通过如下两种方法打开文件：
Func Open(name string) (file *File,err Error)
该方法打开一个名称为name的文件，但是是只读方式，内部实现其调用了OpenFile。
Func OpenFile(name string, flag int,perm uint32) (file *File, err Error)
打开名称为name的文件，flag是打开方式，只读、读写等，perm是权限

【2】写文件

Func (file *File) Write(b []byte) (n int, err Error)
写入byte类型的信息到文件
Func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
在指定位置开始写入byte类型的信息
Func (file *File) WriteString(s  string) (ret int, err Error)
写入string信息到文件

【3】读文件

func (file *File) Read(b []byte) (n int, err Error)
读取数据到b中
Func (file *File) ReadAt(b []byte,off int64) (n int, err Error)
从off开始读取数据到b中

【4】删除文件

func  Remove(name string) Error

调用该函数就可以删除文件名称为name的文件

3.标准设备文件的使用

package main

import (
	"fmt"
	"os"
)

func main() {
	// os.Stdout.Close() 关闭标准输出文件，无法输出
	fmt.Println("are u ok?") //往标准输出设备（屏幕）写内容

	//标准设备文件(os.Stdout)，默认已经打开，用户可以直接使用
	os.Stdout.WriteString("are u ok?\n")

	//os.Stdin.Close() 关闭标准输入，无法输入
	var a int
	fmt.Println("a = ")
	fmt.Scan(&a)
	fmt.Println("a = ", a)
}

4.文件的读写

package main

import (
	"fmt"
	"os"
)

func WriteFile(path string) {
	//打开文件
	f, err := os.Create(path)
	if err != nil {
		fmt.Println(err)
		return
	}
	//使用文件完毕，关闭文件
	defer f.Close()
	var buf string
	for i := 0; i < 10; i++ {
		//"i = 1\n",这个字符串存储在buf中
		buf = fmt.Sprintf("i = %d\n", i)
		_, err2 := f.WriteString(buf)
		if err2 != nil {
			fmt.Println(err)
		}
	}
}

func ReadFile(path string) {
	//打开文件
	f, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		return
	}

	//关闭文件
	defer f.Close()

	buf := make([]byte, 1024*2) //2k大小

	//n代表从文件读取内容的长度
	n, err1 := f.Read(buf)
	if err1 != nil && err1 != io.EOF { //文件出错，同时没有到文件结尾
		fmt.Println("err1 = ", err1)
		return
	}
	fmt.Println("buf = ", string(buf[:n]))
}

func main() {
	path := "./demo.txt"
	WriteFile(path)
	ReadFile(path)
}

输出：

5.借助bufio按行读取文件内容

package main

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

func ReadFile(path string) {
	//打开文件
	f, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		return
	}

	//关闭文件
	defer f.Close()

	//新建一个缓冲区，把内容放在缓冲区
	r := bufio.NewReader(f)

	for {
		//遇到\n结束读取,但是\n也读取进去
		buf, err := r.ReadBytes('\n')
		if err != nil {
			if err == io.EOF { //文件已经结束
				break
			}
			fmt.Println("err = ", err)
		}
		fmt.Printf("%s", string(buf))
	}
}

func main() {
	path := "./demo.txt"
	ReadFile(path)
}

输出：

6.案例：文件的拷贝

package main

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

func main() {
	list := os.Args //获取命令行参数
	if len(list) != 3 {
		fmt.Printf("usage: xxx srcFile  dstFile")
		return
	}

	srcFileName := list[1]
	dstFileName := list[2]
	if srcFileName == dstFileName {
		fmt.Println("源文件和目的文件名字不能相同")
		return
	}

	//只读方式打开源文件
	sF, err1 := os.Open(srcFileName)
	if err1 != nil {
		fmt.Println(err1)
		return
	}

	//创建目的文件
	dF, err2 := os.Create(dstFileName)
	if err2 != nil {
		fmt.Println(err2)
		return
	}

	//操作完毕，需要关闭文件
	defer sF.Close()
	defer dF.Close()

	//核心处理，从源文件读取内容，往目的文件写，读多少写多少
	buf := make([]byte, 4*1024)
	for {
		n, err := sF.Read(buf) //从源文件读取内容
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println("err = ", err)
		}
		//往目的文件写，读多少写多少
		dF.Write(buf[:n])
	}
}

package main

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

func main() {
	args := os.Args //获取命令行参数
	if len(args) != 3 {
		fmt.Printf("usage: xxx  srcFileName  dstFileName")
		return
	}

	srcFileName := args[1]
	dstFileName := args[2]

	//打开源文件
	sF, errS := os.Open(srcFileName)
	if errS != nil {
		fmt.Println(errS)
		return
	}

	//创建目的文件
	dF, errD := os.Create(dstFileName)
	if errD != nil {
		fmt.Println(errD)
		return
	}

	//关闭文件
	defer sF.Close()
	defer dF.Close()

	//进行文件内容拷贝
	r := bufio.NewReader(sF)

	for {
		buf, err := r.ReadBytes('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
		}
		dF.Write(buf)
	}
}