golang-文件读写

文件是存储在外部介质上的数据集合

文件分类：文本文件和二进制文件

文本文件可读性好，占用的数据空间大

二进制文件，可读性差，占用的数据空间小

文件存取方式：随机存取和顺序存放

随机存取：操作速度慢，对磁盘的消耗大

顺序存放：操作数据块，对磁盘的消耗小

golang中的文件操作

只读的方法打开

初级方法

import (
	"fmt"
	"os"
)

func test1() {
	//只读方法
	inputFile, err := os.Open("./main.go")
	if err != nil {
		fmt.Printf("open file faild,err:%s\n", err)
	}
	defer inputFile.Close()
}

高级方法

func test2() {
	//只读方法
	inputFile, err := os.Open("./main.go")
	if err != nil {
		fmt.Printf("open file faild,err:%s\n", err)
		return
	}
	var content []byte
	var buf [128]byte
	for {
		n, err := inputFile.Read(buf[:])
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Printf("open file faild,err:%s\n", err)
			return
		}
		content = append(content, buf[:n]...)
	}
	fmt.Println(string(content))

	defer inputFile.Close()
}

bufio原理

在程序和文件之间，添加一个缓冲区，每次程序读取文件内容的时候，先去缓冲区查看，如果需要的内容，直接获取，如果没有再去文件中获取

由于缓冲是在内存当中的，和程序的交互返回速度会非常快，这样可以大大提高程序的性能和速度

缺点：有的数据是只在缓冲中存储的，如果在缓冲释放之前，没有将数据实例化落盘，会导致数据的丢失

实例

按行操作文件对象

func test3() {
	//只读方法
	inputFile, err := os.Open("./main.go")
	if err != nil {
		fmt.Printf("open file faild,err:%s\n", err)
		return
	}
	defer inputFile.Close()
	reader := bufio.NewReader(inputFile)
	for {
		line, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Printf("open file faild,err:%s\n", err)
			return
		}
		fmt.Println(line)
	}

}

使用ioutil工具读取文件

将之前的file方法封装起来，可以更加方便的使用

func test4() {
	content, err := ioutil.ReadFile("./main.go")
	if err != nil {
		fmt.Printf("open file faild,err:%s\n", err)
		return
	}
	fmt.Println(string(content))

}

读取压缩文件

使用gzip.NewReader(文件句柄)，来操作压缩文件

func test5() {
	file, err := os.Open("./tar.sh.gz")
	if err != nil {
		fmt.Printf("open file faild , Err:%s\n", err)
		return
	}
	defer file.Close()
	reader, err := gzip.NewReader(file)
	if err != nil {
		fmt.Printf("gzip new reader faild , Err:%s\n", err)
		return
	}
	var content []byte // 保存内容的切片
	var buf [128]byte  // 每次读取128字节的切片
	for {
		n, err := reader.Read(buf[:])
		if err == io.EOF {
			if n != 0 {
				content = append(content, buf[:n]...)
			}
			break
		}
		if err != nil {
			fmt.Println("read file:", err)
			return
		}
		content = append(content, buf[:n]...)
	}
	fmt.Println(string(content))  // 将内容输出

}

文件的写入：os.OpenFile() 用法

示例： file,err := os.OpenFile("main.go", os.O_WRONLY|os.O_WRONLY, 0666)

三个参数，

• 第一个是文件路径，当前目录下，可以直接是文件名称
• 第二个是文件的操作方法
  • os.O_WRONLY：只写
  • os.O_CREATE：创建文件
  • os.O_RDONLY：只读
  • os.O_RDWR：读写
  • os.O_TRUNC ：清空
  • os. O_APPEND：追加
• 第三个是文件的权限，r ——> 004 w——> 002 x——> 001

文件操作方法，需要注意不能冲突

文件写入示例

func test6() {
	file, err := os.OpenFile("text.txt", os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("An error occurred with file creation \n")
		return
	}
	str := "hello world,test"
	file.Write([]byte(str))
	defer file.Close()
}

操作完成后，当前目录出现一个text.txt 文件，内容是：hello world,test

这里可以可以考虑使用buffio来实现

COPY和CAT命令实现

copy

package main

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

func main() {
	_, err := CopyFile("target.txt", "copy.go")
	if err != nil {
		fmt.Printf("copy  failed,err:%v\n", err)
		return
	}
	fmt.Println("Copy done!\n")
}
func CopyFile(dstName, srcName string) (written int64, err error) {
	src, err := os.Open(srcName)
	if err != nil {
		fmt.Printf("open source file %s failed,err:%v\n", srcName, err)
		return
	}
	defer src.Close()
	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		fmt.Printf("open dest file %s failed,err:%v\n", srcName, err)
		return
	}
	defer dst.Close()
	return io.Copy(dst, src)
}

cat

package main

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

var (
	num int
)

func cat(r *bufio.Reader, number int) {
	if number == 0 {
		for {
			buf, err := r.ReadBytes('\n')
			if err == io.EOF {
				break
			}
			fmt.Fprintf(os.Stdout, "%s", buf)
		}
	} else {
		for i := 0; i <= number; i++ {
			buf, err := r.ReadBytes('\n')
			if err == io.EOF {
				break
			}
			fmt.Fprintf(os.Stdout, "%s", buf)
		}
		return
	}
}
func main() {
	flag.IntVar(&num, "n", 0, "输入行数")
	flag.Parse()
	if flag.NArg() == 0 {
		cat(bufio.NewReader(os.Stdin), num)
	}
	for i := 0; i < flag.NArg(); i++ {
		f, err := os.Open(flag.Arg(i))
		if err != nil {
			fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n",
				os.Args[0], flag.Arg(i), err.Error())
			continue
		}
		cat(bufio.NewReader(f), num)
	}
}