Go 终端读写 && 文件读写、copy

终端读写

操作终端相关文件句柄常量

• os.Stdin（standard）：标准输入
• os.Stdout：标准输出
• os.Stderr：标准错误输出

标准输出

demo：直接输出和 判断之后输出的结果不一致

func main(){
	//标准输出接口， 格式， 需要格式化的内容
	fmt.Fprintf(os.Stdout, "%s\n", "hello world ~")

	fmt.Fprintln(os.Stdout, "hello, world ~")
}

运行结果：
hello world ~
hello, world ~

标准输入

package main
import (
	"fmt"
)

var (
	firstName, lastName string
	age, salary int
	)

func main(){
	//从键盘获取string类型赋值给fistName
	fmt.Scanf("%s", &firstName)

	//将字符串赋值给lastName, 中间不能空格
	fmt.Sscan("helloworld", &lastName)

	//将一个字符串按照指定格式赋值给变量
	fmt.Sscanf("18-3000", "%d-%d", &age, &salary)

	fmt.Printf("%s\n%s\n%d\n%d", firstName, lastName, age, salary)
}

运行结果：
"holle go"  //手动输入，有空格不行
"holle
helloworld
18
3000

　　

带缓存的输出

package main
import (
	"bufio"
	"fmt"
	"os"
)

func main(){
	//先得到*Write缓存
	buf := bufio.NewWriter(os.Stdout)

	//标准输出接口， 格式， 需要格式化的内容
	fmt.Fprintf(buf, "%s\n", "hello world ~")

	fmt.Fprintln(buf, "hello, world ~")

	buf.Flush()
}

运行结果：
hello world ~
hello, world ~

　　

带缓存的输入

package main
import (
	"bufio"
	"fmt"
	"os"
)

func main(){
	buf := bufio.NewReader(os.Stdin)

	input, err := buf.ReadString('\n')  //delim 定界符
	if err == nil {
		fmt.Println(input)
	}
}

运行结果：
hello world  //手动输入
hello world

　　

读文件

Go 中读取一个文件有多种方式，下面介绍主要的几种：

使用 ioutil 包直接读取

先需要引入 io/ioutil 包，该包默认拥有以下函数供使用者调用

func NopCloser(r io.Reader) io.ReadCloser
func ReadAll(r io.Reader) ([]byte, error)
func ReadDir(dirname string) ([]os.FileInfo, error)
func ReadFile(filename string) ([]byte, error)
func TempDir(dir, prefix string) (name string, err error)
func TempFile(dir, prefix string) (f *os.File, err error)
func WriteFile(filename string, data []byte, perm os.FileMode) error

1）通过指定路径，读取一个文件，并返回 []byte 数据和错误信息

func ReadFile(filename string) ([]byte, error)

demo：通过文件路径读取一个文件，输出文件中的内容

package main
import (
	"fmt"
	"io/ioutil"
)

func readFileByName(fileName string){
	contentSlice, err := ioutil.ReadFile(fileName)
	if err == nil {
		fmt.Print(string(contentSlice))
	}
}

func main(){
	var fileName string = "D:\\code\\go_dev\\projects\\src\\part_10_终端输入输出 && 文件操作\\01_使用os.osutil读取文件\\test.txt"
	readFileByName(fileName)
}

运行结果：
my name is johny
i'm 12 years old
i like speaking english
i like to eat cake

2）通过指定路径，读取一个目录，并返回目录下的文件类型列表和错误信息

func ReadDir(dirname string) ([]os.FileInfo, error)

demo：打开一个目录，输出目录下文件的名称

package main
import (
	"fmt"
	"io/ioutil"
)

func readDiractory(dirName string) {
	fileInfoSlice, err := ioutil.ReadDir(dirName)
	if err != nil {
		fmt.Println(err)
		return
	}
	for _, fileInfo := range fileInfoSlice {
		fileName := fileInfo.Name()
		fmt.Println(fileName)
	}
}

func main() {
	var dirName string = "D:\\code\\go_dev\\file_test"
	readDiractory(dirName)
}

运行结果：
test1.txt
test2.txt
test3.txt

使用 os.Open() 和 os.OpenFile() 函数读取

不论是 os.Open() 还是 os.OpenFile，都返回一个文件类型指针（*File），File 文件类型是一个结构体，封装了关于文件相关操作的方法

关闭一个文件：

File.Close()

1）os.Open()

打开一个将被读取的文件，如果读取成功，返回文件类型，默认的权限是 O_RDONLY，也就是只读权限，否则返回错误

func os.Open(name string) (*File, error)

　　

2）os.OpenFile()

大部分用户会选择这个函数来代替 os.Open() 函数

主要原因是这个函数打开文件时可以指定参数（os.O_APPEND | os.O_CREATE | os.O_WRONLY），以及文件权限（0666）

func os.OpenFile(name string, flag int, perm FileMode) (*File, error)

flag 相关参数：

const (
        O_RDONLY int = syscall.O_RDONLY // 只读打开文件和os.Open()同义
        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  // 如果可以的话，当打开文件时先清空文件
)

3）使用 os.Open() 函数和 ioutil.ReadAll() 函数来读取文件

由于 os.Open 是打开一个文件并返回文件指针类型（*File），因此其实可以结合 ioutil 包中的 ReadAll(r io.Reader) ([]byte, error) 函数来进行读取的（这里还有点疑问）

io.Reader 其实是一个包含 Read() 方法的接口类型，而文件类型（File）是实现了 Read() 方法的

ioutil.ReadAll() 函数从一个文件类型（ io.Reader ）中读取内容直到返回错误或者结束（EOF）时返回读取的数据，当 err == nil 时，数据成功读取到 []byte 中

func ReadAll(r io.Reader) ([]byte, error)

demo：打开一个绝对路径下的文件

package main
import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
)

func readByFielType(fileType io.Reader){
	contentSlice, err := ioutil.ReadAll(fileType)
	if err == nil {
		fmt.Print(string(contentSlice))
	}
}

func main(){
	fileType, err := os.Open("D:\\code\\go_dev\\projects\\src\\part_10_终端输入输出 && 文件操作\\01_使用os.osutil读取文件\\test.txt")
	if err != nil {
		fmt.Printf("file open failed, detail is %v", err.Error())
	} else {
		readByFielType(fileType)
	}
        defer fileType.Close()
}

运行结果：
my name is johny
i'm 12 years old
i like speaking english
i like to eat cake

这种方式会比较繁琐一些，因为使用了 os 的同时借助了 ioutil，但是在读取大文件的时候还是比较有优势的

带缓存的读取（bufio）

bufio 包实现了缓存 IO，创建了 Reader 和 Writer 类型结构体，这种带有缓存的方式，对于文本 I/O 来说，提供了一些便利

bufio 包中对 Reader 类型结构体有很多相关的函数及方法：

//首先定义了一个用来缓冲io.Reader对象的结构体，同时该结构体拥有以下相关的方法
type Reader struct {
}

//NewReader函数用来返回一个默认大小buffer的Reader对象(默认大小好像是4096) 等同于NewReaderSize(rd,4096)
func NewReader(rd io.Reader) *Reader

//该函数返回一个指定大小buffer(size最小为16)的Reader对象，如果 io.Reader参数已经是一个足够大的Reader，它将返回该Reader
func NewReaderSize(rd io.Reader, size int) *Reader

//该方法返回从当前buffer中能被读到的字节数
func (b *Reader) Buffered() int

//Discard方法跳过后续的 n 个字节的数据，返回跳过的字节数。如果0 <= n <= b.Buffered(),该方法将不会从io.Reader中成功读取数据。
func (b *Reader) Discard(n int) (discarded int, err error)

//Peekf方法返回缓存的一个切片，该切片只包含缓存中的前n个字节的数据
func (b *Reader) Peek(n int) ([]byte, error)

//把Reader缓存对象中的数据读入到[]byte类型的p中，并返回读取的字节数。读取成功，err将返回空值
func (b *Reader) Read(p []byte) (n int, err error)

//返回单个字节，如果没有数据返回err
func (b *Reader) ReadByte() (byte, error)

//该方法在b中读取delimz之前的所有数据，返回的切片是已读出的数据的引用，切片中的数据在下一次的读取操作之前是有效的。如果未找到delim，将返回查找结果并返回nil空值。因为缓存的数据可能被下一次的读写操作修改，因此一般使用ReadBytes或者ReadString，他们返回的都是数据拷贝
func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

//功能同ReadSlice，返回数据的拷贝
func (b *Reader) ReadBytes(delim byte) ([]byte, error)

//功能同ReadBytes,返回字符串
func (b *Reader) ReadString(delim byte) (string, error)

//该方法是一个低水平的读取方式，一般建议使用ReadBytes('\n') 或 ReadString('\n')，或者使用一个 Scanner来代替。ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片，用于读取一行数据，不包括行尾标记（\n 或 \r\n）
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

//读取单个UTF-8字符并返回一个rune和字节大小
func (b *Reader) ReadRune() (r rune, size int, err error)

demo：使用 NewReader() 函数返回一个 *Reader 类型，然后使用 ReadString() 方法读取文件内容，使用 for 循环，一直读到文件结尾

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

func bufioRead(){
	fileType, err := os.Open("D:\\golang_workspace\\file_test\\test.txt")
	if err != nil {
		fmt.Printf("file open failed, detail is %v", err.Error())
		os.Exit(2)
	}
	defer fileType.Close()

	var bufReader *bufio.Reader = bufio.NewReader(fileType)
	for {
		contents, err := bufReader.ReadString('\n')
		if err != io.EOF {
			fmt.Print(contents)
		} else {
			break
		}
	}
}

func main(){
	bufioRead()
}

运行结果：
想带你逃学看一场演唱会
想你难过时在我怀中流泪
想和你背包走遍天南地北
想你共我尝尽人生的滋味
想下雨时小伞中有你依偎
想把酒言欢时也有你作陪

写文件

上面的读操作的方式同样也支持写操作

使用 ioutil 包进行文件写入

写入 []byte 类型的数据到 filename 文件中，文件的权限为 perm

func WriteFile(filename string, data []byte, perm os.FileMode) error

demo：使用 WriteFile() 函数写入内容到文件

package main
import (
	"fmt"
	"io/ioutil"
)

func ioutilWrite(){
	var contents string = "hello world ~"
	var data []byte = []byte(contents)
	err := ioutil.WriteFile("D:\\golang_workspace\\file_test\\test.txt", data, 0644)
	if err != nil {
		fmt.Printf("open file failed, detail is %v", err)
	} else {
		fmt.Println("write success ~")
	}
}

func main(){
	ioutilWrite()
}

运行结果：
write success ~  //覆盖写入

使用 os.OpenFile() 函数进行文件写入

因为 os.OpenFile() 函数会打开文件，并返回文件类型结构体指针，而该文件类型是一个结构体，拥有一些写入相关的方法

func os.OpenFile(name string, flag int, perm FileMode) (*File, error)

flag 相关参数及含义：

const (
        O_RDONLY int = syscall.O_RDONLY // 只读打开文件和os.Open()同义
        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  // 如果可以的话，当打开文件时先清空文件
)

文件类型结构体以及相关写入文件的方法：

1）写入长度为b字节切片到文件f中，返回写入字节号和错误信息。当n不等于len(b)时，将返回非空的err

func (f *File) Write(b []byte) (n int, err error)

2）在off偏移量出向文件f写入长度为b的字节

func (f *File) WriteAt(b []byte, off int64) (n int, err error)

3）类似于Write方法，但是写入内容是字符串而不是字节切片

func (f *File) WriteString(s string) (n int, err error)

demo：使用 os.OpenFile() 函数打开文件，使用 Write() 和 WriteString() 方法将内容写入到文件

package main
import (
	"fmt"
	"os"
)

func osOpenWrite(){
	fileType, errOpen := os.OpenFile("D:\\golang_workspace\\file_test\\test.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if errOpen != nil {
		fmt.Printf("openfile failed, detail is %v", errOpen.Error())
		return
	}
	defer fileType.Close()

	//写入字符串
	_, errWrite1 := fileType.WriteString("hello world")
	if errWrite1 != nil {
		fmt.Printf("write file error, detail is %v", errWrite1.Error())
	} else {
		fmt.Println("write string success ~")
	}

	//写入字符切片
	_, errWrite2 := fileType.Write([]byte("hello world"))
	if errWrite2 != nil {
		fmt.Printf("write file error, detail is %v", errWrite2.Error())
	} else {
		fmt.Println("write []byte success ~")
	}
}

func main(){
	osOpenWrite()
}

运行结果：
write string success ~
write []byte success ~

带缓存的写入（bufio）

bufio 和 io 包中很多操作都是相似的，唯一不同的是 bufio 提供了一些缓冲的操作，如果对文件操作比较频繁的，使用 bufio 还是能提高程序的性能和效率的

在 bufio 中，有一个 Writer 类型结构体，与其相关的方法支持一系列的写入操作：

//Writer是一个空的结构体，一般需要使用NewWriter或者NewWriterSize来初始化一个结构体对象
type Writer struct {
        // contains filtered or unexported fields
}

//NewWriterSize和NewWriter函数
//返回默认缓冲大小的Writer对象(默认是4096)
func NewWriter(w io.Writer) *Writer

//指定缓冲大小创建一个Writer对象
func NewWriterSize(w io.Writer, size int) *Writer

//Writer对象相关的写入数据的方法

//把p中的内容写入buffer,返回写入的字节数和错误信息。如果nn<len(p),返回错误信息中会包含为什么写入的数据比较短
func (b *Writer) Write(p []byte) (nn int, err error)
//将buffer中的数据写入 io.Writer
func (b *Writer) Flush() error

//以下三个方法可以直接写入到文件中
//写入单个字节
func (b *Writer) WriteByte(c byte) error
//写入单个Unicode指针返回写入字节数错误信息
func (b *Writer) WriteRune(r rune) (size int, err error)
//写入字符串并返回写入字节数和错误信息
func (b *Writer) WriteString(s string) (int, error)

demo：使用 NewWriter() 函数得到一个 *Writer（指针类型结构体），然后调用 Write() 方法将内容写入到文件，最后调用 Flush() 方法把数据刷新到磁盘

package main
import (
	"bufio"
	"fmt"
	"os"
)

func bufioWrite(){
	fileType, errOpen := os.OpenFile("D:\\golang_workspace\\file_test\\test.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if errOpen != nil {
		fmt.Printf("openfile failed, detail is %v", errOpen.Error())
		return
	}
	defer fileType.Close()

	//生成 *Writer 指针结构体
	var writer *bufio.Writer = bufio.NewWriter(fileType)
	_, errWrite := writer.Write([]byte("hello world ~"))
	if errWrite != nil {
		fmt.Printf("file write error, detail is %v", errWrite.Error())
	}

	//刷新数据到磁盘
	errFlush := writer.Flush()
	if errFlush != nil {
		fmt.Println("file flush error")
		panic(errFlush)
	} else {
		fmt.Println("write file success")
	}
}

func main(){
	bufioWrite()
}

运行结果：
write file success

文件 copy

demo：把一个文件的内容，拷贝到另一个文件中

package main
import (
	"fmt"
	"io"
	"os"
)

func main(){
	var srcFileName string = "D:\\golang_workspace\\file_test\\source.txt"
	var targetFileName string = "D:\\golang_workspace\\file_test\\target.txt"
	CopyFile(srcFileName, targetFileName)
}

func CopyFile(srcFileName, targetFileName string){
	srcFile, err := os.Open(srcFileName)
	if err != nil {
		fmt.Printf("open srcfile failed, err:[%v]", err)
	}
	defer srcFile.Close()

	targetFile, err := os.OpenFile(targetFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		fmt.Printf("open targetfile failed, err:[%v]", err)
	}
	defer targetFile.Close()

	written, err := io.Copy(targetFile, srcFile)
	if err != nil {
		fmt.Printf("file copy failed, err[%v]", err)
	}
	fmt.Printf("copy complete, writen[%v]", written)
}

运行结果：
copy complete, writen[14]

　　

总结：

Go 语言中，文件操作读和写用到了三个包，分别是 ioutil    os    bufio：

1. ioutil.ReadFile,   ioutil.ReadDir,  ioutil.ReadAll       和       ioutil.WriteFile
2. os.Open      和      os.OpenFile
3. bufio.Reader      和      bufio.Writer

其中也有穿插使用，比如：os.Open 和 ioutil.ReadAll，os.Open 和 bufio.Reader，os.OpenFile 和 bufio.Writer

ending ~