文件是存储在外部介质上的数据集合
文件分类：文本文件和二进制文件
文本文件可读性好，占用的数据空间大
二进制文件，可读性差，占用的数据空间小
文件存取方式：随机存取和顺序存放
随机存取：操作速度慢，对磁盘的消耗大
顺序存放：操作数据块，对磁盘的消耗小
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)
}
}
