Go语言之Go语言文件处理

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)
}