Golang(Go语言) 文件操作 总结

文件操作

读取文件

方法1：

从文件中读取指定个数的字符，当输入len <= 0时代表读取全部内容

import (
	"fmt"
	"os"
)
func readFromFile(filename string,len int) (string,error){
	left := len
	text := make([]byte,0,0)
	/*打开文件*/
	file,err := os.Open(filename)
	/*打开文件失败则返回空内容及错误信息*/
	if err != nil{
		return string(text),errors.New("file open fail!")
	}else{
		/*设置读取缓冲区大小*/
		bs := make([]byte,1024*8,1024*8)
		n := -1
		for {
			/*读取内容*/
			n, err = file.Read(bs)
			/*n为0 或者 err ==EOF代表读取结束*/
			if n == 0 || err == io.EOF {
				break
			}
			/*要求读取指定个数内容*/
			if len > 0{
				/*更新剩余字符数*/
				left -= n
				/*仍有剩余则直接将此次读取内容全部添加至text*/
				if left >= 0{
					text = append(text, bs[:n]...)
				}else {/*否则代表剩下可读字符 < 此次读取的字符，只存入可读字符数*/
					text = append(text, bs[:(left+n)]...)
				}
				/*如果没有剩余可读字符数，则退出循环*/
				if left <= 0{
					break
				}
			}else{
				/*直接读取n个字符*/
				text = append(text, bs[:n]...)
			}
			/*继续下轮读取*/
		}
	}
	/*返回读取到的内容*/
	return string(text),nil
}

方法2：带缓冲区读取

import (
	"fmt"
	"os"
	"bufio"
	"io"
)
func PrintFile(filename string) {
	file,err := os.Open(filename)
	if err != nil{
		fmt.Println("open file err=",err)
	}

	defer file.Close()

	//创建一个带缓冲区的 *Reader
	reader := bufio.NewReader(file)

	for{
		str,err := reader.ReadString('\n')//读取到一个换行结束
		if err == io.EOF{ //表示到达文件末尾
			break
		}
		fmt.Printf(str)
	}
}

ioutil

import (
	"fmt"
	"io/ioutil"
)
func PrintFileByIoutil(filename string) {	
	content,err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Printf("read file err=%v",err)
	}
	//fmt.Printf("%T",content)
	fmt.Printf("%v",string(content)) //content 是 []byte 类型，需要强转
}

写入文件

方法一：

向文件中写入指定内容，如果文件不存在则会创建新文件，写入成功则返回写入的字符个数

func writeToFile(filename ,text string, flag int) (int,error){
	/*打开文件*/
	file,err := os.OpenFile(filename,flag,os.ModePerm)
	if err != nil{/*打开文件失败*/
		return 0,errors.New("open file fail!")
	}
    defer file.Close()
    writer := bufio.NewWriter(file)
    /*写入文件*/
    n,err := writer.WriteString(text)
    if err != nil{/*写入异常*/
        return 0,errors.New("write error!")
    }else{/*成功写入*/
		writer.Flush() //刷新缓冲区
        return n,nil
    }
}

方法二：

func WriteFile(filename,data string, flag int) bool {
	
	file,err := os.OpenFile(filename,flag,0666)
	if err != nil {
		fmt.Printf("open file err=%v\n",err)
		return false
	}
	defer file.Close()

	writer := bufio.NewWriter(file)
	writer.WriteString(data)
	writer.Flush()

	return true
}

复制文件

将一个文件内容复制到另一个文件

func copyFile(srcFile,dstFile string)(int64,error){
	/*打开源文件*/
	file_s,err := os.Open(srcFile)
	if err != nil{
		return  0,errors.New("srcFile open fail!")
	}
	/*打开目标文件*/
	file_d ,err := os.OpenFile(dstFile,os.O_RDWR | os.O_CREATE ,os.ModePerm)
	if err != nil{
		return  0,errors.New("dstFile open fail!")
	}
	/*延迟关闭文件*/
	defer file_s.Close()
	defer file_d.Close()
	/*拷贝*/
	return io.Copy(file_d,file_s)
}

方法二：

func CopyFile(srcfile,dstfile string)bool{
    //采用ioutil.ReadFile()
	datas,err := ioutil.ReadFile(srcfile)
	if err != nil {
		fmt.Printf("read file err=%v\n",err)
		return false
	}
	
	err = ioutil.WriteFile(dstfile,datas,0666)
	if err != nil {
		fmt.Printf("write file err=%v\n",err)
		return false
	}
	return true
}

判断文件是否存在

func PathExists(filename string)(bool,error){
	_,err := os.Stat(filename)
	if err == nil {
		return true,nil
	}
	if os.IsNotExist(err) {
		return false,nil
	}
	return false,err
}