文件基本操作
创建空文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package main
import (
"log"
"os"
)
var (
f *os.File
err error
)
func main() {
f, err = os.Create("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
log.Println(f)
}
|
裁剪文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package main
import (
"log"
"os"
)
func main() {
// 裁剪一个文件到size个字节。
// 如果文件本来就少于size个字节，则文件中原始内容得以保留，剩余的字节以null字节填充。
// 如果文件本来超过size个字节，则超过的字节会被抛弃。
// 这样我们总是得到精确的size个字节的文件。
// 传入0则会清空文件。
var size = 100
err := os.Truncate("test.txt", int64(size))
if err != nil {
log.Fatal(err)
}
}
|
获取文件信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package main
import (
"fmt"
"os"
)
var (
fileInfo os.FileInfo
err error
)
func main() {
fileInfo, err = os.Stat("test.txt")
if err != nil {
panic(err)
}
fmt.Println("File name:", fileInfo.Name())
fmt.Println("Size in bytes:", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Last modified:", fileInfo.ModTime())
fmt.Println("Is Directory: ", fileInfo.IsDir())
fmt.Printf("System interface type: %T\n", fileInfo.Sys())
fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
}
|
重命名和移动
1
2
3
4
5
6
7
8
9
10
11
12
|
package main
import (
"os"
)
func main() {
originPath, newPath := "test.txt", "text.txt"
if err := os.Rename(originPath, newPath); err != nil {
panic(err)
}
}
|
删除文件
1
2
3
4
5
6
7
8
9
10
11
|
package main
import (
"os"
)
func main() {
if err := os.Remove("text.txt"); err != nil {
panic(err)
}
}
|
打开文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
package main
import (
"log"
"os"
)
func main() {
// 简单地以只读的方式打开。下面的例子会介绍读写的例子。
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
file.Close()
// OpenFile提供更多的选项。
// 第二个是打开时的属性
// 最后一个参数是权限模式permission mode
file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
file.Close()
// 下面的属性可以单独使用，也可以组合使用。
// os.O_RDONLY // 只读
// os.O_WRONLY // 只写
// os.O_RDWR // 读写
// os.O_APPEND // 往文件中添建（Append）
// os.O_CREATE // 如果文件不存在则先创建
// os.O_TRUNC // 文件打开时清空文件
// os.O_EXCL // 和O_CREATE一起使用，文件不能存在
// os.O_SYNC // 以同步I/O的方式打开
}
|
判断文件是否存在
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package main
import (
"log"
"os"
)
func main() {
// 文件不存在则返回error
fileInfo, err := os.Stat("test.txt")
if err != nil {
if os.IsNotExist(err) {
log.Fatal("File does not exist.")
}
}
log.Println("File does exist. File information:")
log.Println(fileInfo)
}
|
测试读写权限
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
package main
import (
"log"
"os"
)
func main() {
// 测试写权限
// 注意文件不存在也会返回error，需要检查error的信息来判断到底是哪个错误导致。
file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Write permission denied.")
}
}
file.Close()
// 测试读权限
file, err = os.OpenFile("test.txt", os.O_RDONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Read permission denied.")
}
}
file.Close()
}
|
改变权限、拥有者、时间戳
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package main
import (
"log"
"os"
"time"
)
func main() {
// 使用Linux风格改变文件权限
err := os.Chmod("test.txt", 0777)
if err != nil {
log.Println(err)
}
// 改变文件所有者
err = os.Chown("test.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Println(err)
}
// 改变时间戳
twoDaysFromNow := time.Now().Add(48 * time.Hour)
lastAccessTime := twoDaysFromNow
lastModifyTime := twoDaysFromNow
err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
if err != nil {
log.Println(err)
}
}
|
硬链接和软连接
一个普通的文件是一个指向硬盘的inode的指针。
- 硬链接创建一个新的指针指向同一个地方。只有所有的链接被删除后文件才会被删除。硬链接只在相同的文件系统中才工作。
- symbolic link，又叫软连接。它不直接指向硬盘中的相同的地方，而是通过名字引用其它文件。他们可以指向不同的文件系统中的不同文件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
package main
import (
"fmt"
"log"
"os"
)
func main() {
// 创建一个硬链接。
// 创建后同一个文件内容会有两个文件名，改变一个文件的内容会影响另一个。
// 删除和重命名不会影响另一个。
err := os.Link("test.txt", "test_hard_link.txt")
if err != nil {
log.Fatal(err)
}
// Create a symlink
err = os.Symlink("test.txt", "test_symbol_link.txt")
if err != nil {
log.Fatal(err)
}
// Lstat返回一个文件的信息，但是当文件是一个软链接时，它返回软链接的信息，而不是引用的文件的信息。
fileInfo, err := os.Lstat("test_symbol_link.txt")
if err != nil {
log.Fatal(err)
}
fmt.Printf("Link info: %+v", fileInfo)
// 改变软链接的拥有者不会影响原始文件。
err = os.Lchown("test_symbol_link.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Fatal(err)
}
}
|
文件读写
复制文件
os.Open/os.Create返回os.File，os.File实现了io.ReaderWriter接口，io.Copy参数就是io.Write和io.Reader。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
package main
import (
"io"
"log"
"os"
)
var (
srcFile *os.File
dstFile *os.File
err error
)
func main() {
if srcFile, err = os.Open("test.txt"); err != nil {
panic(err)
}
defer srcFile.Close()
if dstFile, err = os.Create("test_copy.txt"); err != nil {
panic(err)
}
defer dstFile.Close()
written, err := io.Copy(dstFile, srcFile)
if err != nil {
panic(err)
}
log.Printf("%d bytes copied.\n", written)
// flush to disk
if err = dstFile.Sync(); err != nil {
panic(err)
}
}
|
跳转到指定位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package main
import (
"io"
"log"
"os"
)
func main() {
var (
position int64
)
file, _ := os.Open("test.txt")
file.Seek(5, io.SeekStart)
position, _ = file.Seek(-2, io.SeekCurrent)
log.Printf("cur position %d", position)
position, _ = file.Seek(0, io.SeekCurrent)
log.Printf("cur position %d", position)
position, _ = file.Seek(0, io.SeekStart)
log.Printf("start position %d", position)
}
|
写文件
使用os包写入一个打开的文件。其它的包如bufio提供了一些方法，但是它们不是必须的。
因为Go的可执行文件是静态链接的，程序里import的每一个包都会增加可执行文件的大小。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package main
import (
"log"
"os"
)
func main() {
// 可写方式打开文件
file, err := os.OpenFile(
"test.txt",
os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
0666,
)
// os.O_TRUNC 打开时清空文件
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 写字节到文件中
byteSlice := []byte("Bytes!\n")
bytesWritten, err := file.Write(byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Wrote %d bytes.\n", bytesWritten)
}
|
简单写文件
os包有一个非常有用的方法WriteFile()可以一次处理创建或者打开文件、写入字节切片和关闭文件一系列的操作。
1
2
3
4
5
6
7
8
9
|
package main
import "os"
func main() {
if err := os.WriteFile("test.txt", []byte("write file\n"), 066); err != nil {
panic(err)
}
}
|
缓存写文件
bufio包提供了带缓存功能的writer，可以在写字节到硬盘前使用内存缓存。
- 节省操作硬盘I/O的时间
- 减少硬盘的磨损以及提升性能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package main
import (
"bufio"
"log"
"os"
)
func main() {
// 如果不指定O_WRONLY，会写入失败
file, err := os.OpenFile("test.txt", os.O_WRONLY|os.O_APPEND, 066)
if err != nil {
panic(err)
}
defer file.Close()
w := bufio.NewWriter(file) // default written 4096
// bufio.NewWriterSize
written, err := w.WriteString("<append by buffer>\n")
if err != nil {
panic(err)
}
log.Println(written)
buffered, available := w.Buffered(), w.Available() // 已缓存，可缓存
log.Printf("buffered %d, available %d", buffered, available)
if err := w.Flush(); err != nil {
panic(err)
}
log.Printf("buffered %d, available %d", w.Buffered(), w.Available())
}
|
读取最多N个字节
os.File提供了文件操作的基本功能， 而io、bufio提供了额外的辅助函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package main
import (
"log"
"os"
)
func main() {
// 打开文件，默认为 只读
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
buffer := make([]byte, 512) // 最多读取512字节，如果不满512，有多少读多少
n, err := f.Read(buffer)
if err != nil {
panic(err)
}
log.Printf("read %d bytes: %s\n", n, string(buffer))
}
|
读取正好N个字节
这里使用的是io包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package main
import (
"io"
"log"
"os"
)
func main() {
// 打开文件，默认为 只读
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
buffer := make([]byte, 512) // 读取恰好512字节，如果不满512，报错EOF
n, err := io.ReadFull(f, buffer)
if err != nil {
panic(err)
}
log.Printf("read %d bytes: %s\n", n, string(buffer))
}
|
读取最少N个字节
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package main
import (
"errors"
"io"
"log"
"os"
)
func main() {
// 打开文件，默认为 只读
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
buffer := make([]byte, 512)
// 读取至少512字节，如果不满512会报错EOF，已读到的部分还是存在buffer中
n, err := io.ReadAtLeast(f, buffer, 512)
if err != nil && !errors.Is(err, io.ErrUnexpectedEOF) {
panic(err)
}
log.Printf("read %d bytes: %s\n", n, string(buffer))
}
|
读取全部字节
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package main
import (
"io"
"log"
"os"
)
func main() {
// 打开文件，默认为 只读
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
bytes, err := io.ReadAll(f) // 读取文件全部内容
if err != nil {
panic(err)
}
log.Printf("read %d bytes, in string %s, in hex %x\n", len(bytes), bytes, bytes)
}
|
简单读文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package main
import (
"log"
"os"
)
func main() {
b, err := os.ReadFile("test.txt")
if err != nil {
panic(err)
}
log.Printf("%s\n", b)
}
|
缓存读文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
package main
import (
"bufio"
"log"
"os"
)
func main() {
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
reader := bufio.NewReader(f)
// Peek 不会更新光标
if bs, err := reader.Peek(5); err != nil {
panic(err)
} else {
log.Printf("peek 5 bytes, in string: %s\n", bs)
}
if b, err := reader.ReadByte(); err != nil {
panic(err)
} else {
log.Printf("read byte: %c\n", b)
}
if bs, err := reader.ReadBytes('\n'); err != nil {
panic(err)
} else {
log.Printf("read line: %s", bs)
}
if s, err := reader.ReadString('\n'); err != nil {
panic(err)
} else {
log.Printf("read line %s", s)
}
}
|
bufio.Scanner
Scanner是bufio包下的类型，在处理文件中以分隔符分隔的文本时很有用。
通常我们使用换行符作为分隔符将文件内容分成多行。在CSV文件中，逗号一般作为分隔符。
os.File文件可以被包装成bufio.Scanner，它就像一个缓存reader。
调用Scan()方法去读取下一个分隔符，使用Text()或者Bytes()获取读取的数据。
分隔符可以不是一个简单的字节或者字符，使用SplitFunc自定义实现分隔功能，以及将指针移动多少，返回什么数据。
如果没有指定SplitFunc，缺省的ScanLines会使用newline字符作为分隔符，其它的分隔函数还包括ScanRunes和ScanWords，它们都定义在bufio包中。
1
2
3
4
5
6
|
// To define your own split function, match this fingerprint
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)
// Returning (0, nil, nil) will tell the scanner
// to scan again, but with a bigger buffer because
// it wasn't enough data to reach the delimiter
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
package main
import (
"bufio"
"log"
"os"
)
func main() {
f, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer f.Close()
scanner := bufio.NewScanner(f)
// 缺省的分隔函数是bufio.ScanLines,我们这里使用ScanWords。
// 也可以定制一个SplitFunc类型的分隔函数
scanner.Split(bufio.ScanWords) // 一次返回一个word
// scan下一个token
if success := scanner.Scan(); !success {
// 返回false，可能遇到EOF，也可能遇到错误
if scanner.Err() != nil {
panic(scanner.Err())
} else {
log.Println("reach EOF.")
}
}
// 获取刚读到的数据，Bytes() 或者 Text()
log.Printf("read first word: %s\n", scanner.Text())
// 再次调用scanner.Scan()发现下一个token
}
|
文件打包及压缩
打包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"log"
"os"
)
func main() {
zipFile, err := os.Create("test.zip")
if err != nil {
log.Fatal(err)
}
defer zipFile.Close()
// 创建zip writer
zipWriter := zip.NewWriter(zipFile)
defer zipWriter.Close()
// 往打包文件中写文件。
// 这里我们使用硬编码的内容，你可以遍历一个文件夹，把文件夹下的文件以及它们的内容写入到这个打包文件中。
var filesToArchive = []struct {
Name, Body string
}{
{"test.txt", "String contents of file\n"},
{"test2.txt", "\x61\x62\x63\n"}, //abc
}
// 下面将要打包的内容写入到打包文件中，依次写入。
for _, file := range filesToArchive {
fileWriter, err := zipWriter.Create(file.Name)
if err != nil {
log.Fatal(err)
}
_, err = fileWriter.Write([]byte(file.Body))
if err != nil {
log.Fatal(err)
}
}
}
|
抽取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"io"
"log"
"os"
"path/filepath"
)
func main() {
zipReader, err := zip.OpenReader("test.zip")
if err != nil {
log.Fatal(err)
}
defer zipReader.Close()
// 遍历打包文件中的每一文件/文件夹
for _, file := range zipReader.Reader.File {
// 打包文件中的文件就像普通的一个文件对象一样
zippedFile, err := file.Open()
if err != nil {
log.Fatal(err)
}
defer zippedFile.Close()
// 指定抽取的文件名。
// 你可以指定全路径名或者一个前缀，这样可以把它们放在不同的文件夹中。
// 我们这个例子使用打包文件中相同的文件名。
targetDir := "./"
extractedFilePath := filepath.Join(
targetDir,
file.Name,
)
// 抽取项目或者创建文件夹
if file.FileInfo().IsDir() {
// 创建文件夹并设置同样的权限
log.Println("Creating directory:", extractedFilePath)
os.MkdirAll(extractedFilePath, file.Mode())
} else {
//抽取正常的文件
log.Println("Extracting file:", file.Name)
outputFile, err := os.OpenFile(
extractedFilePath,
os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
file.Mode(),
)
if err != nil {
log.Fatal(err)
}
defer outputFile.Close()
// 通过io.Copy简洁地复制文件内容
_, err = io.Copy(outputFile, zippedFile)
if err != nil {
log.Fatal(err)
}
}
}
}
|
压缩
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
// 这个例子中使用gzip压缩格式，标准库还支持zlib, bz2, flate, lzw
package main
import (
"compress/gzip"
"log"
"os"
)
func main() {
outputFile, err := os.Create("test.txt.gz")
if err != nil {
log.Fatal(err)
}
defer outputFile.Close()
gzipWriter := gzip.NewWriter(outputFile)
defer gzipWriter.Close()
// 当我们写数据到gizp writer时，它会依次压缩数据并写入到底层的文件中。
// 我们不必关心它是如何压缩的，还是像普通的writer一样操作即可。
_, err = gzipWriter.Write([]byte("Gophers rule!\n"))
if err != nil {
log.Fatal(err)
}
log.Println("Compressed data written to file.")
}
|
解压
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
// 这个例子中使用gzip压缩格式，标准库还支持zlib, bz2, flate, lzw
package main
import (
"compress/gzip"
"io"
"log"
"os"
)
func main() {
// 打开一个gzip文件。
// 文件是一个reader，但是我们可以使用各种数据源，比如web服务器返回的gzipped内容，
// 它的内容不是一个文件，而是一个内存流
gzipFile, err := os.Open("test.txt.gz")
if err != nil {
log.Fatal(err)
}
defer gzipFile.Close()
gzipReader, err := gzip.NewReader(gzipFile)
if err != nil {
log.Fatal(err)
}
defer gzipReader.Close()
// 解压缩到一个writer,它是一个file writer
outfileWriter, err := os.Create("unzipped.txt")
if err != nil {
log.Fatal(err)
}
defer outfileWriter.Close()
// 复制内容
_, err = io.Copy(outfileWriter, gzipReader)
if err != nil {
log.Fatal(err)
}
}
|
其它操作
HTTP下载文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package main
import (
"io"
"log"
"net/http"
"os"
)
func main() {
newFile, err := os.Create("devdungeon.html")
if err != nil {
log.Fatal(err)
}
defer newFile.Close()
url := "http://www.devdungeon.com/archive"
response, err := http.Get(url)
if err != nil {
panic(err)
}
defer response.Body.Close()
// 将HTTP response Body中的内容写入到文件
// Body满足reader接口，因此我们可以使用ioutil.Copy
numBytesWritten, err := io.Copy(newFile, response.Body)
if err != nil {
log.Fatal(err)
}
log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}
|
文件哈希
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package main
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"fmt"
"log"
"os"
)
func main() {
// 得到文件内容
data, err := os.ReadFile("test.txt")
if err != nil {
log.Fatal(err)
}
// 计算Hash
fmt.Printf("Md5: %x\n\n", md5.Sum(data))
fmt.Printf("Sha1: %x\n\n", sha1.Sum(data))
fmt.Printf("Sha256: %x\n\n", sha256.Sum256(data))
fmt.Printf("Sha512: %x\n\n", sha512.Sum512(data))
}
|
上面的例子复制整个文件内容到内存中，再传递给hash函数。
另一种方式是创建一个hash writer, 使用Write、WriteString、Copy将数据传给它。
下面的例子使用 md5 hash，也可以使用其它的Writer。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package main
import (
"crypto/md5"
"fmt"
"io"
"log"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 创建一个新的hasher，满足writer接口
hasher := md5.New()
_, err = io.Copy(hasher, file)
if err != nil {
log.Fatal(err)
}
// 计算hash并打印结果。
// 传递 nil 作为参数，因为我们不通参数传递数据，而是通过writer接口。
sum := hasher.Sum(nil)
fmt.Printf("Md5 checksum: %x\n", sum)
}
|
References
NanoDano working-files-go
译文