Go语言的文件读写

小文件的读取

小文件的读取一般使用 "io/ioutil"包即可。

当文件没有被打开，使用ioutil.ReadFile(path)读取文件

//[]byte
func ioutilReadFile() {
	if _, err := ioutil.ReadFile(path); err != nil {
		//因为contents是[]byte类型，直接转换成string类型后会多一行空格,需要使用strings.Replace替换换行符
		// result := strings.Replace(string(contents), "\n", "", 1)
		fmt.Println("ioutilReadFile err:", err)
	}
}

当文件已经被打开，使用ioutil.ReadAll(fileObj)读取句柄

//[]byte
func ioutilReadAll() {
	if fileObj, err := os.Open(path); err != nil {
		fmt.Println("Open err:", err)
	} else {
		defer fileObj.Close()
		if _, err := ioutil.ReadAll(fileObj); err != nil {
			fmt.Println("ReadAll err:", err)
		}
	}
}

大文件的读取

下面提供了分块读取和逐行读取的方式，其中"bufio"对文件的i/o提供了很好的缓存作用。

//[]byte
func readBufio() {

	file, err := os.Open(path)
	if err != nil {
		panic(err)
	}
	defer file.Close()

	bufReader := bufio.NewReader(file)
	buf := make([]byte, 1024)

	for {
		readNum, err := bufReader.Read(buf)
		if err != nil && err != io.EOF {
			panic(err)
		}
		if 0 == readNum {
			break
		}
	}
}

// ReadString
func readBufioLine() {

	file, err := os.OpenFile(path, os.O_RDWR, 0666)
	if err != nil {
		fmt.Println("Open file error!", err)
		return
	}
	defer file.Close()
	buf := bufio.NewReader(file)
	i := 0
	for {
		line, err := buf.ReadString('\n')
		line = strings.TrimSpace(line)
		// a := strings.Split(line, ",")
		// fmt.Println(a)
		// data = append(data, a)
		if err != nil {
			if err == io.EOF {
				break
			} else {
				fmt.Println("Read file error!", err)
				return
			}
		}
		i++
	}
	fmt.Println("read2  I:", i)
	return
}

//[]byte
func readBufioLine2() {
	fi, err := os.Open(path)
	if err != nil {
		fmt.Printf("Error: %s\n", err)
		return
	}
	defer fi.Close()
	i := 0
	br := bufio.NewReader(fi)
	for {
		_, _, c := br.ReadLine()
		if c == io.EOF {
			break
		}
		i++
	}
	fmt.Println("read2  I:", i)
}

一次性写入小文件使用ioutil.WriteFile(path)

ioutil.WriteFile(path,[]byte,0666)//写入文件(字节数组)

几种分步写入文件的方法，一般情况下使用bufio

//使用os.OpenFile()相关函数打开文件对象，并使用文件对象的相关方法进行文件写入操作
func WriteWithFileWrite(name, content string) {
	fileObj, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		fmt.Println("Failed to open the file", err.Error())
		os.Exit(2)
	}
	defer fileObj.Close()
	if _, err := fileObj.WriteString(content); err == nil {
		fmt.Println("Successful writing to the file with os.OpenFile and *File.WriteString method.", content)
	}
	contents := []byte(content)
	if _, err := fileObj.Write(contents); err == nil {
		fmt.Println("Successful writing to thr file with os.OpenFile and *File.Write method.", content)
	}
}

//使用io.WriteString()函数进行数据的写入
func WriteWithIo(name, content string) {
	fileObj, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println("Failed to open the file", err.Error())
		os.Exit(2)
	}
	if _, err := io.WriteString(fileObj, content); err == nil {
		fmt.Println("Successful appending to the file with os.OpenFile and io.WriteString.", content)
	}
}

//使用bufio包中Writer对象的相关方法进行数据的写入
func WriteWithBufio(name, content string) {
	if fileObj, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644); err == nil {
		defer fileObj.Close()
		writeObj := bufio.NewWriterSize(fileObj, 4096)
		//
		if _, err := writeObj.WriteString(content); err == nil {
			fmt.Println("Successful appending buffer and flush to file with bufio's Writer obj WriteString method", content)
		}

		//使用Write方法,需要使用Writer对象的Flush方法将buffer中的数据刷到磁盘
		buf := []byte(content)
		if _, err := writeObj.Write(buf); err == nil {
			fmt.Println("Successful appending to the buffer with os.OpenFile and bufio's Writer obj Write method.", content)
			if err := writeObj.Flush(); err != nil {
				panic(err)
			}
			fmt.Println("Successful flush the buffer data to file ", content)
		}
	}
}

但是一般情况下都会使用bufio来读写文件，主要利用他对文件i/o提供的便利，分步读写文件，虽然时间消耗可能会变大，但是能减少对内存的占用。