Go 文件操作

<部分内容借鉴自网络，如有侵权，预先道歉，请及时联系（rjguanwen001@163.com），我会尽快删除，谢谢！>

Go 文件操作总结

1、基本操作

1.1 创建文件

package main

import (
	"log"
	"os"
)

func main() {
	newFile, err := os.Create("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	newFile.Close()
}

1.2 Truncate文件

package main

import (
	"log"
	"os"
)

func main(){
	// 裁剪一个文件到100个字节。
	// 如果文件本来就少于100个字节，则文件中原始内容得以保留，剩余的字节以null字节填充。
	// 如果文件本来超过100个字节，则超过的字节会被抛弃。
	// 这样我们总是得到精确的100个字节的文件。
	// 传入0则会清空文件。
	err := os.Truncate("example_1.txt", 100)
	if err != nil {
		log.Fatal(err)
	}
}

1.3 获取文件信息

package main

import (
	"fmt"
	"log"
	"os"
)

func main(){
	fi, err := os.Stat("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("文件名：",fi.Name())
	fmt.Println("文件大小：", fi.Size())
	fmt.Println("权限：", fi.Mode())
	fmt.Println("最后修改时间：", fi.ModTime())
	fmt.Println("是否文件夹：", fi.IsDir())
	fmt.Println("系统信息：", fi.Sys())
}

1.4 重命名和移动

package main

import (
	"log"
	"os"
)

func main() {
	// 在 windows 下，通过 Rename 将文件跨卷移动，会报错
	// 当文件 open 后，未 close 时，Rename 方法貌似不起作用，
	// 并且也不会报错，需要注意
	oldPath := "example_1.txt"
	newPath := "example_4.txt"
	err := os.Rename(oldPath, newPath)
	if err != nil {
		log.Fatal(err)
	}
}

1.5 删除文件

package main

import (
	"log"
	"os"
)

func main() {
	err := os.Remove("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
}

1.6 打开和关闭文件

package main

import (
	"log"
	"os"
)

func main() {
	// 以只读方式打开文件
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	file.Close()

	// 第二个参数为打开文件时的属性，可以多个组合使用
	// 第三个参数为权限模式
	file, err = os.OpenFile("example_1.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		// 向文件中添加
	//os.O_CREATE		// 如果文件不存在则先创建
	//os.O_TRUNC		// 文件打开时裁剪文件
	//os.O_EXCL			//
	//os.O_SYNC			// 以同步I/O方式打开
}

1.7 检查文件是否存在

package main

import (
	"fmt"
	"os"
)

func main() {
	_, err := os.Stat("example_2.txt")
	fileExist :=  err == nil || os.IsExist(err)
	fmt.Println(fileExist)
}

1.8 检查读写权限

package main

import (
	"log"
	"os"
)

func main() {

	// 测试写权限，如果文件是只读或者其他原因导致不具备写入权限，则返回 error
	file, err := os.OpenFile("example_1.txt", os.O_WRONLY, 0666)
	if err != nil {
		if os.IsPermission(err) {
			log.Println("错误：无写入权限！")
		}
	}
	file.Close()

	// 测试读权限
	file, err = os.OpenFile("example_1.txt", os.O_RDONLY, 0666)
	if err != nil {
		if os.IsPermission(err) {
			log.Println("错误：无读取权限！")
		}
	}
	file.Close()
}

1.9 改变权限、拥有者、时间戳

package main

import (
	"log"
	"os"
	"time"
)

func main() {
	// 使用 Linux 风格改变文件权限
	err := os.Chmod("example_1.txt", 0777)
	if err != nil {
		log.Println(err)
	}

	// 改变文件所有者 (not supported by windows)
	err = os.Chown("example_1.txt", os.Getuid(), os.Getgid())
	if err != nil {
		log.Println(err)
	}

	// 改变时间戳
	oneDaysFromNow := time.Now().Add(24 * time.Hour)
	lastAccessTime := oneDaysFromNow
	lastModifyTime := oneDaysFromNow

	err = os.Chtimes("example_1.txt", lastAccessTime, lastModifyTime)
	if err != nil {
		log.Println(err)
	}
}

1.10 硬链接与软链接

一个普通的文件是一个指向硬盘的inode的地方。
硬链接创建一个新的指针指向同一个地方。只有所有的链接被删除后文件才会被删除。硬链接只在相同的文件系统中才工作。你可以认为一个硬链接是一个正常的链接。
symbolic link，又叫软连接，和硬链接有点不一样，它不直接指向硬盘中的相同的地方，而是通过名字引用其它文件。他们可以指向不同的文件系统中的不同文件。并不是所有的操作系统都支持软链接。

package main
import (
    "os"
    "log"
    "fmt"
)
func main() {
    // 创建一个硬链接。
    // 创建后同一个文件内容会有两个文件名，改变一个文件的内容会影响另一个。
    // 删除和重命名不会影响另一个。
    err := os.Link("original.txt", "original_also.txt")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("creating sym")
    // Create a symlink
    err = os.Symlink("original.txt", "original_sym.txt")
    if err != nil {
        log.Fatal(err)
    }
    // Lstat返回一个文件的信息，但是当文件是一个软链接时，它返回软链接的信息，而不是引用的文件的信息。
    // Symlink在Windows中不工作。
    fileInfo, err := os.Lstat("original_sym.txt")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Link info: %+v", fileInfo)
    //改变软链接的拥有者不会影响原始文件。
    err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
    if err != nil {
        log.Fatal(err)
    }
}

2、读写文件

2.1 复制文件

package main

import (
	"io"
	"log"
	"os"
)

func main() {
	//打开文件
	oFile, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer oFile.Close()

	// 创建新文件
	nFile, err := os.Create("example_copy.txt")
	if err != nil {
		log.Fatalln(err)
	}
	defer nFile.Close()

	// 从源文件复制字节到目标文件
	bytesWritten, err := io.Copy(nFile, oFile)
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("已复制 %d 字节。", bytesWritten)

	err = nFile.Sync()
	if err != nil {
		log.Fatal(err)
	}
}

2.2 跳转到文件指定位置（Seek）

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	file, _ := os.Open("example_1.txt")
	defer file.Close()

	// 偏离位置，可以是正数也可以是负数
	var offset int64 = 5

	// offset 的初始位置，即相对那个位置进行偏移
	// 0 ：文件开始位置 	os.SEEK_SET
	// 1 ：当前位置 		os.SEEK_CUR
	// 2 ：文件结尾位置 	os.SEEK_END
	var whence int = 0

	newPosition, err := file.Seek(offset, whence)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("向前移动 5：", newPosition)

	// 从当前位置回退 3 个字节
	newPosition, err = file.Seek(-3, os.SEEK_CUR)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("向后移动 2：", newPosition)

	// 获取当前位置
	currentPosition, err := file.Seek(0, 1)
	fmt.Println("当前位置：", currentPosition)

	// 转到文件开始处
	newPosition, err = file.Seek(0, 0)
	if err != nil {
		log.Fatal(err)
	}
	//fmt.Println(newPosition)
}

2.3 写文件

package main

import (
	"log"
	"os"
)

func main() {
	// 以可写方式打开文件
	file, err := os.OpenFile("example_1.txt",
		os.O_WRONLY | os.O_TRUNC | os.O_CREATE,
		0666,
		)

	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	byteSlice := []byte("Hello!\n")
	bytesWriteen, err := file.Write(byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("写入 %d 个字节. \n", bytesWriteen)
}

2.4 快写文件

ioutil 包有一个方法 WriteFile() 可以处理创建/打开文件、写字节切片和关闭文件一些列的操作。如果你需要简洁快速地写字节切片到文件中，可以使用它。

package main

import (
	"io/ioutil"
	"log"
)

func main() {
	err := ioutil.WriteFile("example_1.txt",
		[]byte("Hi, world!\n"), 0666)
	if err != nil {
		log.Fatal(err)
	}
}

2.5 使用缓存写

bufio 包提供了带缓存功能的writer，你可以在写字节到硬盘前使用内存缓存。当你处理很多数据时会很有用，因为它可以节省操作硬盘 I/O 的时间，大大提升性能并减少硬盘磨损。

package main

import (
	"bufio"
	"log"
	"os"
)

func main() {
	file, err := os.OpenFile("example_1.txt", os.O_WRONLY, 0666)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 创建 buffered writer
	bufferedWriter := bufio.NewWriter(file)

	// 写字节到 buffer
	bytesWritten, err := bufferedWriter.Write([]byte{65, 66, 67},)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("写入字节数：%d \n", bytesWritten)

	// 写字符串到 buffer
	bytesWritten, err = bufferedWriter.WriteString("Hello, buffer!\n")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("写入字节数：%d \n", bytesWritten)

	// 检查缓存中的字节数
	unflushedBufferSize := bufferedWriter.Buffered()
	log.Printf("缓存的字节数：%d \n", unflushedBufferSize)

	// 还有多少字节可用（未使用的缓存大小）
	bytesAvailable := bufferedWriter.Available()
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("可用缓存1：%d \n", bytesAvailable)

	// 写缓存到硬盘
	bufferedWriter.Flush()

	bytesAvailable = bufferedWriter.Available()
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("可用缓存2：%d \n", bytesAvailable)

	// 丢弃还没有flush的缓存的内容，清除错误并把它的输出传给参数中的writer
	// 当你想将缓存传给另外一个writer时有用
	bufferedWriter.Reset(bufferedWriter)

	bytesAvailable = bufferedWriter.Available()
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("可用缓存3：%d \n", bytesAvailable)

	// 重新设置缓存的大小
	// 第一个参数是缓存应该输出到哪里，这个例子中我们使用相同的writer。
	// 如果我们设置的新的大小小于第一个参数writer的缓存大小， 比如10，我们不会得到一个10字节大小的缓存，
	// 而是writer的原始大小的缓存，默认是4096。
	// 它的功能主要还是为了扩容。
	bufferedWriter = bufio.NewWriterSize(
		bufferedWriter,
		8000,
		)

	// resize 后检查缓存大小
	bytesAvailable = bufferedWriter.Available()
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("可用缓存4：%d \n", bytesAvailable)

	// 设置 resize 值小于当前缓存大小，此时是不起作用的
	bufferedWriter = bufio.NewWriterSize(
		bufferedWriter,
		800,
	)
	bytesAvailable = bufferedWriter.Available()
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("可用缓存5：%d \n", bytesAvailable)
}

2.6 读取最多 N 个字节

os.File 提供了文件操作的基本功能，而 io、ioutil、bufio 提供了额外的辅助函数。

package main

import (
	"log"
	"os"
)

func main() {
	// 以只读模式打开文件
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 从文件中读取指定长度的字节数据
	byteSlice := make([]byte, 20)
	bytesRead, err := file.Read(byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("读取到的字节数据长度：%d\n", bytesRead)
	log.Printf("读取到的数据：%s \n", byteSlice)
}

2.7 读取正好 N 个字节

package main

import (
	"io"
	"log"
	"os"
)

func main() {

	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	// file.Read()可以读取一个小文件到大的byte slice中，
	// 但是io.ReadFull()在文件的字节数小于byte slice字节数的时候会返回错误
	byteSlice := make([]byte, 5)
	numBytesRead, err := io.ReadFull(file, byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("读取到的字节数: %d\n", numBytesRead)
	log.Printf("读取到的数据: %s\n", byteSlice)
}

2.8 读取至少 N 个字节

package main

import (
	"io"
	"log"
	"os"
)

func main() {
	// 打开文件，只读
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	byteSlice := make([]byte, 512)
	minBytes := 18
	// io.ReadAtLeast()在不能得到最小的字节的时候会返回错误，但会把已读的文件保留
	numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("读取到的字节数: %d\n", numBytesRead)
	log.Printf("读取到的数据: %s\n", byteSlice)
}

2.9 读取全部字节

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
)

func main() {
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	// os.File.Read(), io.ReadFull() 和
	// io.ReadAtLeast() 在读取之前都需要一个固定大小的byte slice。
	// 但ioutil.ReadAll()会读取reader(这个例子中是file)的每一个字节，然后把字节slice返回。
	data, err := ioutil.ReadAll(file)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取到的数据（十六进制）: %x\n", data)
	fmt.Printf("读取到的数据（字符串）: %s\n", data)
	fmt.Println("读取到的数据长度:", len(data))
}

2.10 快读到内存

package main

import (
	"io/ioutil"
	"log"
)

func main() {
    // 直接读取，省略掉文件打开与关闭操作
	data, err := ioutil.ReadFile("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("读取到的数据：%s \n", data)
}

2.11 使用缓存读

缓存 reader 会把一些内容缓存在内存中，它提供了比 os.File 和 io.Reader 更多的函数，缺省的缓存大小是 4096，最小缓存是 16。

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

// 使用缓存读
func main() {
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	bufferedReader := bufio.NewReader(file)

	// 读取字节，当前指针不变
	byteSlice := make([]byte, 5)
	byteSlice, err = bufferedReader.Peek(5)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取 5 个字节：%s \n", byteSlice)

	// 读取，指针同时移动
	numBytesRead, err := bufferedReader.Read(byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取 %d 个字节：%s \n", numBytesRead, byteSlice)

	// 读取一个字节，如果不成功会返回 error
	myByte, err := bufferedReader.ReadByte()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取一个字节：%c \n", myByte)

	// 读取到分隔符，包含分隔符
	dataBytes, err := bufferedReader.ReadBytes('\n')
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取字节：%s \n", dataBytes)

	// 读取到分隔符，包含分隔符，返回字符串
	dataString, err := bufferedReader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("读取字符串：%s \n", dataString)
}

2.12 使用 scanner

Scanner 是 bufio 包下的类型，在处理文件中以分隔符分隔的文本时很有用。
通常我们使用换行符作为分隔符将文件内容分成多行。在 CSV 文件中，逗号一般作为一行内不同元素之间的分隔符。
os.File 文件可以被包装成 bufio.Scanner，它就像一个缓存 reader。
我们会调用 Scan() 方法去读取下一个分隔符，使用 Text() 或者 Bytes() 获取读取的数据。
分隔符可以不是一个简单的字节或者字符，有一个特殊的方法可以实现分隔符的功能，以及将指针移动多少，返回什么数据。
如果没有定制的 SplitFunc 提供，缺省的 ScanLines 会使用 newLine 字符作为分隔符，其他的分隔函数还包括 ScanRunes 和 ScanWords，皆在 bufio 包中。

/ 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

下面的例子，为一个文件创建 bufio.Scanner，并按照单词和单行读取：

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

func main() {
	file, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}

	scanner := bufio.NewScanner(file)

	// 缺省的分隔函数是 buffio.ScanLines，我们这里使用 ScanWords。
	// 也可以定制一个 SplitFunc 类型的分隔函数
	scanner.Split(bufio.ScanWords)

	// scan 下一个 token。
	success := scanner.Scan()
	if success == false {
		// 出现错误或者 EOF
		err = scanner.Err()
		if err == nil {
			log.Println("读取完成，到达文件末尾！")
		} else {
			log.Fatal(err)
		}
	}

	fmt.Println("读取到第一个单词：", scanner.Text())

	//再次调用 scanner.Scan() 发下下一个 token
	//------

	file.Close()

	file2, err := os.Open("example_1.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file2.Close()

	// 尝试按行读取
	scannerLines := bufio.NewScanner(file2)
	scannerLines.Split(bufio.ScanLines)
	for  {
		success2 := scannerLines.Scan()
		if success2 == false {
			// 出现错误或者 EOF
			err = scannerLines.Err()
			if err == nil {
				log.Println("读取完成，到达文件末尾！")
			} else {
				log.Fatal(err)
			}
			break
		} else {
			fmt.Printf("读取到行：<%s>\n", scannerLines.Text())
		}
	}
}

3、压缩

3.1 打包（zip）文件

package main

import (
	"archive/zip"
	"log"
	"os"
)

// 标准库支持zip 及 tar 格式打包
func main() {

	outFile, err := os.Create("example_1.zip")
	if err != nil {
		log.Fatal(err)
	}
	defer outFile.Close()

	// 创建 zip writer
	zipWriter := zip.NewWriter(outFile)

	// 往打包文件中写入文件及数据。
	// 此处我们直接硬编码。你可以遍历文件夹，将其下的文件及内容写入。
	var filesToArchive = []struct{
		Name, Body string
	} {
		{"test1.txt", "Hello, everyone!"},
		{"test2.txt", "\x61\x62\x63\n"},
	}

	// 将要打包的内容写入打包文件
	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)
		}
	}

	// 清理
	err = zipWriter.Close()
	if err != nil {
		log.Fatal(err)
	}
}

3.2 抽取（unzip）文件

package main

import (
	"archive/zip"
	"io"
	"log"
	"os"
	"path/filepath"
)

func main() {

	zipReader, err := zip.OpenReader("example_1.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 := "temp"
		extractedFilePath := filepath.Join(targetDir, file.Name)

		// 抽取项目或者创建文件夹
		if file.FileInfo().IsDir() {
			// 创建文件夹并设置其权限与文件一致
			log.Println("创建文件夹：", extractedFilePath)
			os.MkdirAll(extractedFilePath, file.Mode())
		} else {
			// 抽取正常的文件
			log.Println("抽取文件：", 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)
			}
		}
	}
}

3.3 压缩文件

package main

import (
	"compress/gzip"
	"log"
	"os"
)

// 压缩文件，本例使用 gzip 压缩格式，标准库还支持zlib, bz2, flate, lzw
func main() {
	outputFile, err := os.Create("example.txt.gz")
	if err != nil {
		log.Fatal(err)
	}
	gzipWriter := gzip.NewWriter(outputFile)
	defer gzipWriter.Close()
	// 当我们写如到gizp writer数据时，它会依次压缩数据并写入到底层的文件中。
	// 我们不必关心它是如何压缩的，还是像普通的writer一样操作即可。
	_, err = gzipWriter.Write([]byte("我是数据数据数据!\n"))
	if err != nil {
		log.Fatal(err)
	}
	log.Println("压缩数据已写入文件。")
}

3.4 解压缩文件

package main

import (
	"compress/gzip"
	"io"
	"log"
	"os"
)

func main() {
	// 打开一个gzip文件。
	// 文件是一个reader,但是我们可以使用各种数据源，比如web服务器返回的gzipped内容，
	// 它的内容不是一个文件，而是一个内存流
	gzipFile, err := os.Open("example.txt.gz")
	if err != nil {
		log.Fatal(err)
	}
	gzipReader, err := gzip.NewReader(gzipFile)
	if err != nil {
		log.Fatal(err)
	}
	defer gzipReader.Close()
	// 解压缩到一个 writer,它是一个 file writer
	outfileWriter, err := os.Create("example_unzipped.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer outfileWriter.Close()
	// 复制内容
	_, err = io.Copy(outfileWriter, gzipReader)
	if err != nil {
		log.Fatal(err)
	}
}

4、其他

4.1 临时文件和目录

ioutil 提供了两个函数：TempDir() 和 TempFile()。
使用完毕后，调用者负责删除这些临时文件和文件夹。
有一个好处是，当你传递一个空字符串作为文件夹名的时候，它会在操作系统的临时文件夹中创建这些项目（/tmp on Linux）。
os.TempDir() 返回当前操作系统的临时文件夹。

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
)

func main() {
	// 在系统临时文件夹中创建一个临时文件夹
	tempDirPath, err := ioutil.TempDir("", "myTempDir")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("临时文件夹已创建:", tempDirPath)
	// 在临时文件夹中创建临时文件
	tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("临时文件已创建:", tempFile.Name())
	// ... 做一些操作 ...
	// 关闭文件
	err = tempFile.Close()
	if err != nil {
		log.Fatal(err)
	}
	// 删除我们创建的资源
	err = os.Remove(tempFile.Name())
	if err != nil {
		log.Fatal(err)
	}
	err = os.Remove(tempDirPath)
	if err != nil {
		log.Fatal(err)
	}
}

4.2 通过 HTTP 下载文件

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	newFile, err := os.Create("good_habits.html")
	if err != nil {
		log.Fatal(err)
	}
	defer newFile.Close()
	url := "https://rjguanwen.cn/2019/11/good_habits/"
	response, err := http.Get(url)
	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)
}

4.3 哈希和摘要

package main

import (
	"crypto/md5"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"fmt"
	"io/ioutil"
	"log"
)

func main() {
	// 得到文件内容
	data, err := ioutil.ReadFile("example_1.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 将数据传给它。

package main

import (
	"crypto/md5"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	file, err := os.Open("example_1.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)
}