go 写文件、读文件

写文件：方式有三种

        1.按字符串写

        2.按位置写

        3.按字节写

读文件：方式有两种

        1.按行读

        2.按字节读

一、按字符串写（创建文件-》打开文件-》写入字符串-》再次写入字符串-》关闭文件-》再次打开文件-》再次写入字符串-》关闭文件）

package main
import (
	"fmt"
	"os"
)
func main() {
	url := "./test.txt"
	//1.创建一个空文件
	f,err := os.Create(url)
	if err != nil {
		fmt.Println("创建文件失败 err=",err)
		return
	}
	//2.可读可写模式打开文件 有对文件读写权限6
	f,err = os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}

	//写入字符串
	n,err := f.WriteString("######")
	if err != nil {
		fmt.Println("1 WriteString err:",err)
		return
	} else {
		fmt.Println("1 写入数据成功 n=",n)
	}
	//再次写入字符串
	n,err = f.WriteString("123")
	if err != nil {
		fmt.Println("2 WriteString err:",err)
		return
	} else {
		fmt.Println("2 写入数据成功 n=",n)
	}
	f.Close()

	//再次打开文件
	f,err = os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}
	//再次写入字符串
	n,err = f.WriteString("***")
	if err != nil {
		fmt.Println("3 WriteString err:",err)
		return
	} else {
		fmt.Println("3 写入数据成功 n=",n)
	}
	f.Close()
}

运行序：

打开文件，看到的内容：

注意：同一次打开文件，写入两次字符串，“######” “123”，文件内容为 “######123”。然后关闭文件，再次打开文件写入字符串“***”，此时，写入的字符串便从0位开始写，所以内容变为“***###123”。 那么可以确定，同一次打开文件，进行多次字符串写入会追加到之前的字符串之后，不同次打开文件，则写入内容则重新从0位开始写（写入指针位置从0位开始），覆盖之前的部分内容（具体看写入的字符串是否比之前的长）

带缓冲字符串逐行写入文件：

1.每一行字符串后需要加上换行符  “\r\n"

2.写入后:需要调用 Flush（），因为写入的数据还在缓冲区，需要刷回硬盘

3.写入的字符串位置从0位开始写，将文件中之前的内容覆盖掉

package main

import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	url := "./test.txt"
	//打开一个文件
	f,err := os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	//写入字符串并换行
	str := "我爱你中国!\r\n" // \r\n 表示换行
	//写入时创建带缓存的 Writer
	writer := bufio.NewWriter(f)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}
	//将缓存刷入硬盘
	writer.Flush()
}

在文件后追加写入：

1.文件中本来是有内容的，打开文件，在文件已有内容后写入数据

2. os.OpenFile(url,os.O_RDWR|os.O_APPEND,6)    os.O_RDWR | os.O_APPEND 可读可写并且可以追加内容写到文件中

package main

import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	url := "./test.txt"
	//打开一个文件
	f,err := os.OpenFile(url,os.O_RDWR|os.O_APPEND,6)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	//写入字符串并换行
	str := "解放军是我们最可爱的人!\r\n" // \r\n 表示换行
	//写入时创建带缓存的 Writer
	writer := bufio.NewWriter(f)
	for i := 0; i < 10; i++ {
		writer.WriteString(str)
	}
	//将缓存刷入硬盘
	writer.Flush()
}

二、按位置写

打开文件后需要用Seek()函数调整读写指针位置。（位置是按字节指针位置）

Seek()参数：

        参数1：offset 偏移量。 正数：向文件尾偏，负数：向文件头偏

        参数2：whence 偏移的起始位置：

                        io.SeekStart:文件的起始位置0

                        io.SeekCurrent:文件当前的位置

                        io.SeekEnd:文件的结尾位置

        返回值：表示从文件的起始位置到当前文件读写指针位置的偏移量。

        指针调整位置，一般都是配合字节写入来进行写入的。示例看按字节写入代码

三、按字节写

WriteAt(); 按字节写入文件

参数1：b []byte   写入的字节切片

参数2：off  写入的指针位置（f.Seek() 返回的调整指针位置）

package main
import (
	"fmt"
	"io"
	"os"
)
func main() {
	url := "./test.txt"
	//1.创建一个空文件
	f,err := os.Create(url)
	if err != nil {
		fmt.Println("创建文件失败 err=",err)
		return
	}
	//2.可读可写模式打开文件 有对文件读写权限6
	f,err = os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}

	//写入字符串
	n,err := f.WriteString("0123456789abcdefghijklmnopqrstuvwxyz")
	if err != nil {
		fmt.Println("1 WriteString err:",err)
		return
	} else {
		fmt.Println("1 写入数据成功 n=",n)
	}
	//调整指针
	off,_ := f.Seek(5,io.SeekStart)
	fmt.Println("off=",off)

	//再次写入字符串
	n,err = f.WriteAt([]byte("***"),off)
	if err != nil {
		fmt.Println("2 WriteString err:",err)
		return
	} else {
		fmt.Println("2 写入数据成功 n=",n)
	}
	f.Close()
}

示例先写入 “0123456789abcdefghijklmnopqrstuvwxyz”  再调整指针后写入“***”

根据调整指针，产生的结果如下：

四、按行读取文件

1.打开文件后，需要先创建一个带缓冲区的 Reader   bufio.NewReader()，其实就是将文件中的内容预加载到缓存中，方便快速读取出来。当然，文件的内容非常多的时候，它是一部分一部分加载到缓冲区的，并不会将所有内容一次全部加载完。

2.按行读取数据  reader.ReadBytes('\n')

3.读取出来的数据是 buf  []byte 切片 ，要读取多行进行循环读取即可，每读一行指针就会往后移

4.文件读到结尾，reader.ReadBytes('\n') 将返回err  err== io.EOF(结尾标志)

package main
import (
	"bufio"
	"fmt"
	"io"
	"os"
)
func main() {
	url := "./test.txt"
	//打开一个文件
	f,err := os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	//创建一个带有缓冲区的Reader
	reader := bufio.NewReader(f)
	for {
		//读取一条数据
		buf,err2 := reader.ReadBytes('\n')
		if err2 != nil && err2 == io.EOF {
			fmt.Println("读完了所有数据")
			return
		} else if err2 != nil {
			fmt.Println("ReaderBytes err:",err2)
			return
		}
		fmt.Println(string(buf))
	}
}

按行读取文件也可以用reader.ReadString('\n')

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)
func main() {
	url := "./test.txt"
	//打开一个文件
	f,err := os.OpenFile(url,os.O_RDWR,6)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	//创建一个带有缓冲区的Reader
	reader := bufio.NewReader(f)
	for {
		//读取一条数据
		buf,err2 := reader.ReadString('\n')
		if err2 == io.EOF {
			fmt.Println("读完了所有数据")
			break
		}
		fmt.Println(string(buf))
	}
}