GO 语言文件处理
Go 语言文件创建
os包提供了操作系统函数的不依赖平台的接口。设计为Unix风格的，虽然错误处理是go风格的；失败的调用会返回错误值而非错误码。通常错误值里包含更多信息。
创建目录
当前目录
func Getwd() (dir string, err error)
Getwd返回一个对应当前工作目录的根路径。如果当前目录可以经过多条路径抵达（因为硬链接），Getwd会返回其中一个。
package main
import (
"fmt"
"os"
"syscall"
)
func main() {
st, err := os.Getwd()
if err == nil {
fmt.Println(st)
}
fmt.Println(syscall.Getwd())
}
创建目录
func Mkdir(name string, perm FileMode) error
// perm 表示文件的权限 0777 表示所有权限
package main
import (
"fmt"
"os"
)
func main() {
err := os.Mkdir("练习", 0777)
if err != nil {
fmt.Println("报错")
}
}
Mkdir使用指定的权限和名称创建一个目录。如果出错，会返回*PathError底层类型的错误。
func IsExist(err error) bool
返回一个布尔值说明该错误是否表示一个文件或目录已经存在。ErrExist和一些系统调用错误会使它返回真。
func IsNotExist(err error) bool
返回一个布尔值说明该错误是否表示一个文件或目录不存在。ErrNotExist和一些系统调用错误会使它返回真。
func MkdirAll(path string, perm FileMode) error
MkdirAll使用指定的权限和名称创建一个目录，包括任何必要的上级目录，并返回nil，否则返回错误。权限位perm会应用在每一个被本函数创建的目录上。如果path指定了一个已经存在的目录，MkdirAll不做任何操作并返回nil。
func Rename(oldpath, newpath string) error
Rename修改一个文件的名字，移动一个文件。可能会有一些个操作系统特定的限制。
代码实现：
package main
import (
"fmt"
"os"
)
func main() {
path, err := os.Getwd() //获取当前路径
if err != nil {
fmt.Println("获取当前路径失败")
}
fmt.Println("当前路径为", path)
err = os.Mkdir("./oldboy", 0777)
if err != nil {
fmt.Println("创建文件夹失败")
if os.IsExist(err) {
fmt.Println("文件已经存在")
}
if os.IsNotExist(err) {
fmt.Println("文件不存在！")
}
}
err = os.MkdirAll("./oldboy/go", 0777)
if err != nil {
fmt.Println("mkdirall err : %v\n", err)
}
err = os.Rename("./oldboy/go", "./oldboy/golang")
if err != nil {
fmt.Printf("rename err : %v\n", err)
}
}
创建文件
创建文件操作常用函数和方法：
func Create(name string) (file *File, err error)
=====================
源码剖析
func Create(name string) (*File, error) {
return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}
0666 表示权限 只存在读写，没有执行
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
testlog.Open(name)
f, err := openFileNolog(name, flag, perm)
if err != nil {
return nil, err
}
f.appendMode = flag&O_APPEND != 0
return f, nil
}
Create采用模式0666（任何人都可读写，不可执行）创建一个名为name的文件，如果文件已存在会截断它（为空文件）。如果成功，返回的文件对象可用于I/O；对应的文件描述符具有O_RDWR模式。如果出错，错误底层类型是*PathError。
func NewFile(fd uintptr, name string) *File
NewFile使用给出的Unix文件描述符和名称创建一个文件。
func (f *File) Close() error
Close关闭文件f，使文件不能用于读写。它返回可能出现的错误。
func (f *File) Name() string
Name方法返回（提供给Open/Create等方法的）文件名称。
func (f *File) Stat() (fi FileInfo, err error)
Stat返回描述文件f的FileInfo类型值。如果出错，错误底层类型是*PathError。
func SameFile(fi1, fi2 FileInfo) bool
SameFile返回fi1和fi2是否在描述同一个文件。例如，在Unix这表示二者底层结构的设备和索引节点是相同的；在其他系统中可能是根据路径名确定的。
SameFile应只使用本包Stat函数返回的FileInfo类型值为参数，其他情况下，它会返回假。
type FileInfo interface {
Name() string // 文件的名字（不含扩展名）
Size() int64 // 普通文件返回值表示其大小；其他文件的返回值含义各系统不同
Mode() FileMode // 文件的模式位
ModTime() time.Time // 文件的修改时间
IsDir() bool // 等价于Mode().IsDir()
Sys() interface{} // 底层数据来源（可以返回nil）
}
func (m FileMode) IsRegular() bool
IsRegular报告m是否是一个普通文件。
func (m FileMode) IsDir() bool
IsDir报告m是否是一个目录。
代码实现：
package main
import (
"fmt"
"os"
"syscall"
)
func main() {
file1, err := os.Create("./file1.txt")
if err != nil {
fmt.Printf("create file1 err : %v\n", err)
}
if file1 != nil {
// defer 延迟操作，不影响后面使用，当函数执行完毕后，自动关闭文件
defer func(file *os.File) {
file.Close()
}(file1)
fmt.Println("create file1 success ")
}
file2 := os.NewFile(uintptr(syscall.Stdin), "./file2.txt")
if file2 != nil {
defer func(file *os.File) { file.Close() }(file2)
fmt.Println("newfile file2 success ")
}
fileName := file1.Name()
fmt.Printf("file1 name is %v\n", fileName)
fileInfo1, err := file1.Stat()
if err != nil {
fmt.Printf("get file1 info err : %v\n", err)
}
fileInfo2, err := file2.Stat()
if err != nil {
fmt.Printf("get file2 info err : %v\n", err)
}
b := os.SameFile(fileInfo1, fileInfo2)
if b {
fmt.Println("file1 与 file2 是同一个文件")
} else {
fmt.Println("file1 与 file2 不是同一个文件")
}
fileMode1 := fileInfo1.Mode()
b = fileMode1.IsRegular()
if b {
fmt.Println("file1 是普通文件")
} else {
fmt.Println("file1 不是普通文件")
}
b = fileMode1.IsDir()
if b {
fmt.Println("file1 是普通目录")
} else {
fmt.Println("file1 不是普通目录")
}
}
D:\goprogram\go\src\管道
λ go run test.go
create file1 success
newfile file2 success
file1 name is ./file1.txt
file1 与 file2 不是同一个文件
file1 是普通文件
file1 不是普通目录
Go 语言文件写入
文件写入
文件写入常用函数和方法：
func Open(name string) (file *File, err error)
Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。
打开标记：
const (
O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
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 // 如果可能，打开时清空文件
)
文件权限（unix权限位）：只有在创建文件时才需要，不需要创建文件可以设置为 0。os库虽然提供常量，但是我一般直接写数字，如0664。
如果你需要设置多个打开标记和unix权限位，需要使用位操作符"|"
func (f *File) Write(b []byte) (n int, err error)
Write向文件中写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) WriteAt(b []byte, off int64) (n int, err error)
WriteAt在指定的位置（相对于文件开始位置）写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) WriteString(s string) (ret int, err error)
WriteString类似Write，但接受一个字符串参数。
代码实现：
package main
import (
"fmt"
"os"
)
func main() {
file1, err := os.Open("./file1.txt")
if err != nil {
fmt.Printf("open file1.txt err : %v\n", err)
}
if file1 != nil {
defer func(file *os.File) { file.Close() }(file1)
}
file2, err := os.OpenFile("./file2.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
fmt.Printf("openfile file2 err : %v\n", err)
}
if file2 != nil {
defer func(file *os.File) { file.Close() }(file2)
}
b1 := []byte("hello world ! hi write test !\n")
off, err := file2.Write(b1)
if err != nil {
fmt.Printf("file2 write err : %v\n", err)
}
fmt.Printf("file2 write success , off is %v\n", off)
b2 := []byte("hello golang ! hi writeat test !\n")
off, err = file2.WriteAt(b2, int64(off))
if err != nil {
fmt.Printf("file2 writeat err : %v\n", err)
}
fmt.Printf("file2 writeat success , off is %v\n", off)
str := "this is write string test .\n"
off, err = file2.WriteString(str)
if err != nil {
fmt.Printf("file2 write string err : %v\n", err)
}
fmt.Printf("file2 write string success , off is %v\n", off)
}
运行结果：
file2 write success , off is 30
file2 writeat success , off is 33
file2 write string success , off is 28
cat file2.txt
hello world ! hi write test !
hello golang ! hi writeat test !
this is write string test .
缓冲写入
bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。
缓冲写入常用函数和方法：
func NewWriter(w io.Writer) *Writer
NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
func NewWriterSize(w io.Writer, size int) *Writer
NewWriterSize创建一个具有最少有size尺寸的缓冲、写入w的Writer。如果参数w已经是一个具有足够大缓冲的Writer类型值，会返回w。
func (b *Writer) Reset(w io.Writer)
Reset丢弃缓冲中的数据，清除任何错误，将b重设为将其输出写入w。
func (b *Writer) Write(p []byte) (nn int, err error)
Write将p的内容写入缓冲。返回写入的字节数。如果返回值nn < len(p)，还会返回一个错误说明原因。
func (b *Writer) WriteString(s string) (int, error)
WriteString写入一个字符串。返回写入的字节数。如果返回值nn < len(s)，还会返回一个错误说明原因。
func (b *Writer) WriteByte(c byte) error
WriteByte写入单个字节。
func (b *Writer) WriteRune(r rune) (size int, err error)
WriteRune写入一个unicode码值（的utf-8编码），返回写入的字节数和可能的错误。
func (b *Writer) Buffered() int
Buffered返回缓冲中已使用的字节数。
func (b *Writer) Available() int
Available返回缓冲中还有多少字节未使用。
func (b *Writer) Flush() error
Flush方法将缓冲中的数据写入下层的io.Writer接口。
代码实现：
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
file, err := os.OpenFile("./file.txt", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Printf("open file err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
fmt.Println("open file success")
write1 := bufio.NewWriter(file)
space1 := write1.Available()
fmt.Printf("默认缓冲区有 %d 字节\n", space1)
insertByte, err := write1.Write([]byte("默认大小缓冲写入\n"))
if err != nil {
fmt.Printf("write err : %v\n", err)
}
fmt.Printf("write success , 写入 %d 字节\n", insertByte)
useSpace1 := write1.Buffered()
fmt.Printf("默认缓冲区已经使用 %d 字节\n", useSpace1)
//丢弃缓冲中的数据
write1.Reset(file)
write2 := bufio.NewWriterSize(file, 10000)
insertByte2, err := write2.WriteString("this is write string test.\n")
if err != nil {
fmt.Printf("write string err : %v\n", err)
}
fmt.Printf("write string success , 写入 %d 字节\n", insertByte2)
err = write2.WriteByte('a')
if err != nil {
fmt.Printf("write byte err : %v\n", err)
}
insertByte3, err := write2.WriteRune('哈')
if err != nil {
fmt.Printf("write rune err : %v\n", err)
}
fmt.Printf("write rune success , 写入 %d 字节\n", insertByte3)
err = write2.Flush()
if err != nil {
fmt.Printf("write2 flush err : %v\n", err)
}
fmt.Println("write2 flush success")
}
运行结果：
open file success
默认缓冲区有 4096 字节
write success , 写入 25 字节
默认缓冲区已经使用 25 字节
write string success , 写入 27 字节
write rune success , 写入 3 字节
write2 flush success
cat file.txt
this is write string test.
a哈
指定文件写入
使用 io/ioutil 包向指定的文件中写入数据
指定文件写入常用函数：
func WriteFile(filename string, data []byte, perm os.FileMode) error
函数向filename指定的文件中写入数据。如果文件不存在将按给出的权限创建文件，否则在写入数据之前清空文件。
os.FileMode 代表文件的模式和权限位。
这些字位在所有的操作系统都有相同的含义，因此文件的信息可以在不同的操作系统之间安全的移植。
不是所有的位都能用于所有的系统，唯一共有的是用于表示目录的ModeDir位。
const (
// 单字符是被String方法用于格式化的属性缩写。
ModeDir FileMode = 1 << (32 - 1 - iota) // d: 目录
ModeAppend // a: 只能写入，且只能写入到末尾
ModeExclusive // l: 用于执行
ModeTemporary // T: 临时文件（非备份文件）
ModeSymlink // L: 符号链接（不是快捷方式文件）
ModeDevice // D: 设备
ModeNamedPipe // p: 命名管道（FIFO）
ModeSocket // S: Unix域socket
ModeSetuid // u: 表示文件具有其创建者用户id权限
ModeSetgid // g: 表示文件具有其创建者组id的权限
ModeCharDevice // c: 字符设备，需已设置ModeDevice
ModeSticky // t: 只有root/创建者能删除/移动文件
// 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
)
这些被定义的位是FileMode最重要的位。
另外9个不重要的位为标准Unix rwxrwxrwx权限（任何人都可读、写、运行）。
这些（重要）位的值应被视为公共API的一部分，可能会用于线路协议或硬盘标识：它们不能被修改，但可以添加新的位。
代码实现：
package main
import (
"fmt"
"io/ioutil"
"os"
)
func main() {
str := "this is ioutil.WriteFile() test."
err := ioutil.WriteFile("./ioutilWriteFile.txt", []byte(str), os.ModePerm)
if err != nil {
fmt.Printf("ioutil.WriteFile() write ./ioutilWriteFile.txt err : %v\n", err)
}
fmt.Println("ioutil.WriteFile() write ./ioutilWriteFile.txt success.")
}
Go 语言文件读取
使用 os包按byte读取文件常用方法：
func (f *File) Read(b []byte) (n int, err error)
Read方法从f中读取最多len(b)字节数据并写入b。它返回读取的字节数和可能遇到的任何错误。文件终止标志是读取0个字节且返回值err为io.EOF。
func (f *File) ReadAt(b []byte, off int64) (n int, err error)
ReadAt从指定的位置（相对于文件开始位置）读取len(b)字节数据并写入b。它返回读取的字节数和可能遇到的任何错误。当n<len(b)时，本方法总是会返回错误；如果是因为到达文件结尾，返回值err会是io.EOF。
package main
import (
"fmt"
"os"
)
func main() {
file, err := os.Open("./file.txt")
if err != nil {
fmt.Printf("open ./file.txt err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
var b1 = make([]byte, 102)
space1, err := file.Read(b1)
if err != nil {
fmt.Printf("file read err : %v\n", err)
}
fmt.Printf("file read success , 读取 %d 字节。\n", space1)
fmt.Printf("读取内容：\n%s\n", string(b1))
b2 := make([]byte, 205)
space2, err := file.ReadAt(b2, int64(space1))
if err != nil {
fmt.Printf("file readat err : %v\n", err)
}
fmt.Printf("file readat success , 读取 %d 字节。\n", space2)
fmt.Printf("读取内容：\n%s\n", string(b2))
}
缓冲读取
bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。
缓冲读取常用函数和方法：
func NewReader(rd io.Reader) *Reader
NewReader创建一个具有默认大小缓冲、从r读取的*Reader。
func (b *Reader) Read(p []byte) (n int, err error)
Read读取数据写入p。本方法返回写入p的字节数。本方法一次调用最多会调用下层Reader接口一次Read方法，因此返回值n可能小于len(p)。读取到达结尾时，返回值n将为0而err将为io.EOF。
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
ReadLine是一个低水平的行数据读取原语。大多数调用者应使用ReadBytes('\n')或ReadString('\n')代替，或者使用Scanner。
ReadLine尝试返回一行数据，不包括行尾标志的字节。如果行太长超过了缓冲，返回值isPrefix会被设为true，并返回行的前面一部分。该行剩下的部分将在之后的调用中返回。返回值isPrefix会在返回该行最后一个片段时才设为false。返回切片是缓冲的子切片，只在下一次读取操作之前有效。ReadLine要么返回一个非nil的line，要么返回一个非nil的err，两个返回值至少一个非nil。
返回的文本不包含行尾的标志字节（"\r\n"或"\n"）。如果输入流结束时没有行尾标志字节，方法不会出错，也不会指出这一情况。在调用ReadLine之后调用UnreadByte会总是吐出最后一个读取的字节（很可能是该行的行尾标志字节），即使该字节不是ReadLine返回值的一部分。
func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
ReadSlice读取直到第一次遇到delim字节，返回缓冲里的包含已读取的数据和delim字节的切片。该返回值只在下一次读取操作之前合法。如果ReadSlice放在在读取到delim之前遇到了错误，它会返回在错误之前读取的数据在缓冲中的切片以及该错误（一般是io.EOF）。如果在读取到delim之前缓冲就被写满了，ReadSlice失败并返回ErrBufferFull。因为ReadSlice的返回值会被下一次I/O操作重写，调用者应尽量使用ReadBytes或ReadString替代本法功法。当且仅当ReadBytes方法返回的切片不以delim结尾时，会返回一个非nil的错误。
func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
ReadBytes读取直到第一次遇到delim字节，返回一个包含已读取的数据和delim字节的切片。如果ReadBytes方法在读取到delim之前遇到了错误，它会返回在错误之前读取的数据以及该错误（一般是io.EOF）。当且仅当ReadBytes方法返回的切片不以delim结尾时，会返回一个非nil的错误。
func (b *Reader) ReadString(delim byte) (line string, err error)
ReadString读取直到第一次遇到delim字节，返回一个包含已读取的数据和delim字节的字符串。如果ReadString方法在读取到delim之前遇到了错误，它会返回在错误之前读取的数据以及该错误（一般是io.EOF）。当且仅当ReadString方法返回的切片不以delim结尾时，会返回一个非nil的错误。
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
file, err := os.Open("./file.txt")
if err != nil {
fmt.Printf("os open ./file.txt err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
read1 := bufio.NewReader(file)
var b1 = make([]byte, 102)
readByte1, err := read1.Read(b1)
if err != nil {
fmt.Printf("read err : %v\n", err)
}
fmt.Printf("read success , 读取 %d 字节\n读取的内容：\n%s\n", readByte1, string(b1))
var line []byte
for {
data, prefix, err := read1.ReadLine()
if err == io.EOF {
// fmt.Println(err)
break
}
line = append(line, data...)
if !prefix {
// fmt.Printf("data:%s\n", string(line))
}
}
fmt.Println(string(line))
}
读取整个文件
使用 io/ioutil 包实现了读取整个文件功能
读取整个文件常用函数：
func ReadAll(r io.Reader) ([]byte, error)
ReadAll从r读取数据直到EOF或遇到error，返回读取的数据和遇到的错误。成功的调用返回的err为nil而非EOF。因为本函数定义为读取r直到EOF，它不会将读取返回的EOF视为应报告的错误。
func ReadFile(filename string) ([]byte, error)
ReadFile 从filename指定的文件中读取数据并返回文件的内容。成功的调用返回的err为nil而非EOF。因为本函数定义为读取整个文件，它不会将读取返回的EOF视为应报告的错误。
package main
import (
"fmt"
"io/ioutil"
"os"
)
func main() {
file, err := os.Open("./file.txt")
if err != nil {
fmt.Printf("open ./file.txt err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
data1, err := ioutil.ReadAll(file)
if err != nil {
fmt.Printf("ioutil read all err : %v\n", err)
}
fmt.Printf("ioutil read all success.\n内容：\n%s\n", string(data1))
data2, err := ioutil.ReadFile("./file.txt")
if err != nil {
fmt.Printf("ioutil read file err : %v\n", err)
}
fmt.Printf("ioutil read file success.\n内容：\n%s\n", string(data2))
}
Go 语言文件删除
判断文件是否存在
判断文件或目录是否存在常用函数：
func IsExist(err error) bool
返回一个布尔值说明该错误是否表示一个文件或目录已经存在。ErrExist和一些系统调用错误会使它返回真。
func IsNotExist(err error) bool
返回一个布尔值说明该错误是否表示一个文件或目录不存在。ErrNotExist和一些系统调用错误会使它返回真。
package main
import (
"fmt"
"os"
)
func main() {
path := "./oldboy/golang.go"
b, err := PathExists(path)
if err != nil {
fmt.Printf("PathExists(%s),err(%v)\n", path, err)
}
if b {
fmt.Printf("path %s 存在\n", path)
} else {
fmt.Printf("path %s 不存在\n", path)
}
}
/*
判断文件或文件夹是否存在
如果返回的错误为nil,说明文件或文件夹存在
如果返回的错误类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
如果返回的错误为其它类型,则不确定是否在存在
*/
func PathExists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
文件删除
文件删除常用函数：
func Remove(name string) error
Remove删除name指定的文件或目录。如果出错，会返回*PathError底层类型的错误。
func RemoveAll(path string) error
RemoveAll删除path指定的文件，或目录及它包含的任何下级对象。它会尝试删除所有东西，除非遇到错误并返回。如果path指定的对象不存在，RemoveAll会返回nil而不返回错误。
package main
import (
"fmt"
"os"
)
func main() {
err := os.Remove("./file1.txt")
if err != nil {
fmt.Printf("remove ./file1.txt err : %v\n", err)
}
err = os.RemoveAll("./file2.txt")
if err != nil {
fmt.Printf("remove all ./file2.txt err : %v\n", err)
}
}
Go 语言压缩文件读写
压缩文件读写
tar包实现了tar格式压缩文件的存取。本包目标是覆盖大多数tar的变种，包括GNU和BSD生成的tar文件。
压缩文件读写常用函数和方法：
func NewWriter(w io.Writer) *Writer
NewWriter创建一个写入w的*Writer。
func FileInfoHeader(fi os.FileInfo, link string) (*Header, error)
FileInfoHeader返回一个根据fi填写了部分字段的Header。 如果fi描述一个符号链接，FileInfoHeader函数将link参数作为链接目标。如果fi描述一个目录，会在名字后面添加斜杠。因为os.FileInfo接口的Name方法只返回它描述的文件的无路径名，有可能需要将返回值的Name字段修改为文件的完整路径名。
func (tw *Writer) WriteHeader(hdr *Header) error
WriteHeader写入hdr并准备接受文件内容。如果不是第一次调用本方法，会调用Flush。在Close之后调用本方法会返回ErrWriteAfterClose。
func (tw *Writer) Write(b []byte) (n int, err error)
Write向tar档案文件的当前记录中写入数据。如果写入的数据总数超出上一次调用WriteHeader的参数hdr.Size字节，返回ErrWriteTooLong错误。
func (tw *Writer) Flush() error
Flush结束当前文件的写入。（可选的）
func (tw *Writer) Close() error
Close关闭tar档案文件，会将缓冲中未写入下层的io.Writer接口的数据刷新到下层。
func NewReader(r io.Reader) *Reader
NewReader创建一个从r读取的Reader。
func (tr *Reader) Next() (*Header, error)
转入tar档案文件下一记录，它会返回下一记录的头域。
func (tr *Reader) Read(b []byte) (n int, err error)
从档案文件的当前记录读取数据，到达记录末端时返回(0, EOF)，直到调用Next方法转入下一记录。
tar.gz 文件写入，代码实现：
package main
import (
"archive/tar"
"fmt"
"os"
)
func main() {
fileName := "./file.tar.gz"
insertByte := []byte("this is test tar weite.")
file, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
if err != nil {
fmt.Printf("open file ./file.tar.gz err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
write := tar.NewWriter(file)
fileInfo, err := os.Stat(fileName)
if err != nil {
fmt.Printf("os stat err : %v\n", err)
}
hdr, err := tar.FileInfoHeader(fileInfo, "")
if err != nil {
fmt.Printf("tar FileInfoHeader err : %v\n", err)
} else {
fmt.Printf("hdr.Size is %v \n", hdr.Size)
hdr.Size = int64(len(insertByte))
}
err = write.WriteHeader(hdr)
if err != nil {
fmt.Printf("write WriteHeader err : %v\n", err)
}
ret, err := write.Write(insertByte)
if err != nil {
fmt.Printf("write ./file.tar.gz err : %v\n", err)
} else {
fmt.Printf("write ./file.tar.gz success . return number is %d \n", ret)
}
err = write.Flush()
if err != nil {
fmt.Printf("write flush err : %v\n", err)
}
err = write.Close()
if err != nil {
fmt.Printf("write close err : %v\n", err)
}
}
package main
import (
"archive/tar"
"fmt"
"os"
)
func main() {
fileName := "./file.tar.gz"
file, err := os.Open(fileName)
if err != nil {
fmt.Printf("open file ./file.tar.gz err : %v\n", err)
}
if file != nil {
defer func(file *os.File) { file.Close() }(file)
}
read := tar.NewReader(file)
hdr, err := read.Next()
var getByte = make([]byte, hdr.Size)
_, err = read.Read(getByte)
if err != nil {
fmt.Printf("read err : %v\n", err)
}
fmt.Println(string(getByte))
}
其它压缩文件操作
compress/flate 包实现了deflate压缩数据格式。gzip包和zlib包实现了对基于deflate的文件格式的访问。
compress/gzip 包实现了gzip格式压缩文件的读写。
compress/zlib 包实现了对zlib格式压缩数据的读写。
Go 语言文件操作应用
从一个文件拷贝到另一个文件
package main
import (
"fmt"
"io"
"os"
)
func CopyFile(dstName, srcName string) (writeen int64, err error) {
src, err := os.Open(dstName)
if err != nil {
fmt.Println(err)
return
}
defer src.Close()
dst, err := os.OpenFile(srcName, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
fmt.Println(err)
return
}
defer dst.Close()
return io.Copy(dst, src)
}
func main() {
CopyFile("./oldboy/golang.go", "./oldboy/golang_copy.go")
fmt.Println("copy done.")
}
二、写入内容到Excel。
使用 encoding/csv 包实现写入内容到Excel。
csv读写逗号分隔值（csv）的文件。
一个csv分拣包含零到多条记录，每条记录一到多个字段。每个记录用换行符分隔。最后一条记录后面可以有换行符，也可以没有。
写入内容到Excel常用函数和方法：
func NewWriter(w io.Writer) *Writer
NewWriter返回一个写入w的*Writer。
func (w *Writer) Write(record []string) (err error)
向w中写入一条记录，会自行添加必需的引号。记录是字符串切片，每个字符串代表一个字段。
func (w *Writer) Flush()
将缓存中的数据写入底层的io.Writer。要检查Flush时是否发生错误的话，应调用Error方法。
func (w *Writer) WriteAll(records [][]string) (err error)
WriteAll方法使用Write方法向w写入多条记录，并在最后调用Flush方法清空缓存。
代码实现：
package main
import (
"encoding/csv"
"math/rand"
"os"
"strconv"
)
func main() {
file, err := os.Create("./oldboy.xls")
if err != nil {
panic(err)
}
defer func(file *os.File) { file.Close() }(file)
file.WriteString("\xEF\xBB\xBF") // 写入UTF-8 BOM
w := csv.NewWriter(file)
w.Write([]string{"编号", "姓名", "年龄"})
for i := 1; i < 11; i++ {
num := strconv.FormatInt(int64(i), 10)
age := strconv.FormatInt(int64(rand.Intn(100)), 10)
w.Write([]string{num, "name" + num, age})
}
w.Flush()
records := [][]string{}
for i := 11; i < 21; i++ {
num := strconv.FormatInt(int64(i), 10)
age := strconv.FormatInt(int64(rand.Intn(100)), 10)
str := []string{num, "name" + num, age}
records = append(records, str)
}
w.WriteAll(records)
}