Go文件操作大全
1 介绍
万物皆文件
UNIX 的一个根底设计就是"万物皆文件"(everything is a file)。咱们不用晓得一个文件到底映射成什么，操作系统的设施驱动形象成文件。操作系统为设施提供了文件格式的接口。
Go语言中的reader和writer接口也相似。咱们只需简略的读写字节，不用晓得reader的数据来自哪里，也不用晓得writer将数据发送到哪里。
你能够在/dev下查看可用的设施，有些可能须要较高的权限能力拜访。
2 基本操作
2.1 创立空文件
//创立新文件 ，如果文件存在，有内容会清空func makeNewFile() { newFile, err := os.Create("test.txt") if err != nil { log.Fatal(err) } log.Println(newFile) err = newFile.Close() if err != nil { log.Fatal(err) }}2.2 Truncate文件
-rw-r--r-- 1 zhangqiuli24 staff 697B Oct 8 14:30 test.txt//重制文件// 裁剪一个文件到100个字节。// 如果文件原本就少于100个字节，则文件中原始内容得以保留，残余的字节以null字节填充。// 如果文件原本超过100个字节，则超过的字节会被摈弃。// 这样咱们总是失去准确的100个字节的文件。// 传入0则会清空文件。func truncateFile(){ err := os.Truncate("test.txt", 100) if err != nil { log.Fatal(err) }}-rw-r--r-- 1 zhangqiuli24 staff 100B Oct 8 14:32 test.txt2.3 文件信息
//文件信息func fileInfos(){ // 如果文件不存在，则返回谬误 fileInfo, err = os.Stat("test.txt") if err != nil { log.Fatal(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())}$ go run main.goFile name: test.txtSize in bytes: 100Permissions: -rw-r--r--Last modified: 2022-10-08 14:32:02.822465128 +0800 CSTIs Directory: falseSystem interface type: *syscall.Stat_tSystem info: &{Dev:16777231 Mode:33188 Nlink:1 Ino:47887641 Uid:502 Gid:20 Rdev:0 Pad_cgo_0:[0 0 0 0] Atimespec:{Sec:1665210724 Nsec:86545989} Mtimespec:{Sec:1665210722 Nsec:822465128} Ctimespec:{Sec:1665210722 Nsec:822465128} Birthtimespec:{Sec:1665210638 Nsec:435434306} Size:100 Blocks:8 Blksize:4096 Flags:0 Gen:0 Lspare:0 Qspare:[0 0]}2.4重命名和挪动
//rename 和 move 原理一样func renameAndMove(){ originalPath := "test.txt" newPath := "test2.txt" err := os.Rename(originalPath, newPath) if err != nil { log.Fatal(err) }}2.5 删除文件
//删除文件func removeFile(){ err := os.Remove("test.txt") if err != nil { log.Fatal(err) }}2.6 关上和敞开文件
func openCloseFile(){ // 简略地以只读的形式关上。上面的例子会介绍读写的例子。 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() // 上面的属性能够独自应用，也能够组合应用。 // 组合应用时能够应用 OR 操作设置 OpenFile的第二个参数，例如： // os.O_CREATE|os.O_APPEND // 或者 os.O_CREATE|os.O_TRUNC|os.O_WRONLY // 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的形式关上}2.7 查看文件是否存在
//查看文件是否存在func checkFileExist(){ // 文件不存在则返回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)}2.8 查看读写权限
func main() { // 这个例子测试写权限，如果没有写权限则返回error。 // 留神文件不存在也会返回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()}2.9 扭转权限、拥有者、工夫戳
package mainimport ( "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) }}2.10 硬链接和软链接
一个一般的文件是一个指向硬盘的inode的中央。
硬链接创立一个新的指针指向同一个中央。只有所有的链接被删除后文件才会被删除。硬链接只在雷同的文件系统中才工作。你能够认为一个硬链接是一个失常的链接。
symbolic link，又叫软连贯，和硬链接有点不一样，它不间接指向硬盘中的雷同的中央，而是通过名字援用其它文件。他们能够指向不同的文件系统中的不同文件。并不是所有的操作系统都反对软链接。
package mainimport ( "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) }}3 读写
3.1 复制文件
package mainimport ( "os" "log" "io")func main() { // 关上原始文件 originalFile, err := os.Open("test.txt") if err != nil { log.Fatal(err) } defer originalFile.Close() // 创立新的文件作为指标文件 newFile, err := os.Create("test_copy.txt") if err != nil { log.Fatal(err) } defer newFile.Close() // 从源中复制字节到指标文件 bytesWritten, err := io.Copy(newFile, originalFile) if err != nil { log.Fatal(err) } log.Printf("Copied %d bytes.", bytesWritten) // 将文件内容flush到硬盘中 err = newFile.Sync() if err != nil { log.Fatal(err) }}3.2 跳转到文件指定地位(Seek)
package mainimport ( "os" "fmt" "log")func main() { file, _ := os.Open("test.txt") defer file.Close() // 偏离地位，能够是负数也能够是正数 var offset int64 = 5 // 用来计算offset的初始地位 // 0 = 文件开始地位 // 1 = 以后地位 // 2 = 文件结尾处 var whence int = 0 newPosition, err := file.Seek(offset, whence) if err != nil { log.Fatal(err) } fmt.Println("Just moved to 5:", newPosition) // 从以后地位回退两个字节 newPosition, err = file.Seek(-2, 1) if err != nil { log.Fatal(err) } fmt.Println("Just moved back two:", newPosition) // 应用上面的技巧失去以后的地位 currentPosition, err := file.Seek(0, 1) fmt.Println("Current position:", currentPosition) // 转到文件开始处 newPosition, err = file.Seek(0, 0) if err != nil { log.Fatal(err) } fmt.Println("Position after seeking 0,0:", newPosition)}$ go run main.goJust moved to 5: 5Just moved back two: 3Current position: 3Position after seeking 0,0: 03.3 写文件
能够应用os包写入一个关上的文件。
因为Go可执行包是动态链接的可执行文件，你import的每一个包都会减少你的可执行文件的大小。其它的包如io、｀ioutil｀、｀bufio｀提供了一些办法，然而它们不是必须的。
package mainimport ( "os" "log")func main() { // 可写形式关上文件 file, err := os.OpenFile( "test.txt", os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666, ) 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)}3.4 快写文件
ioutil包有一个十分有用的办法WriteFile()能够解决创立／关上文件、写字节slice和敞开文件一系列的操作。如果你须要简洁疾速地写字节slice到文件中，你能够应用它。
package mainimport ( "io/ioutil" "log")func main() { err := ioutil.WriteFile("test.txt", []byte("Hi\n"), 0666) if err != nil { log.Fatal(err) }}3.5 应用缓存写
bufio包提供了带缓存性能的writer，所以你能够在写字节到硬盘前应用内存缓存。当你解决很多的数据很有用，因为它能够节俭操作硬盘I/O的工夫。在其它一些状况下它也很有用，比方你每次写一个字节，把它们攒在内存缓存中，而后一次写入到硬盘中，缩小硬盘的磨损以及晋升性能。
package mainimport ( "bufio" "log" "os")func main() { // 关上文件，只写 file, err := os.OpenFile("test.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("Bytes written: %d\n", bytesWritten) // 写字符串到buffer // 也能够应用 WriteRune() 和 WriteByte() bytesWritten, err = bufferedWriter.WriteString( "Buffered string\n", ) if err != nil { log.Fatal(err) } log.Printf("Bytes written: %d\n", bytesWritten) // 查看缓存中的字节数 unflushedBufferSize := bufferedWriter.Buffered() log.Printf("Bytes buffered: %d\n", unflushedBufferSize) // 还有多少字节可用（未应用的缓存大小） bytesAvailable := bufferedWriter.Available() if err != nil { log.Fatal(err) } log.Printf("Available buffer: %d\n", bytesAvailable) // 写内存buffer到硬盘 bufferedWriter.Flush() // 抛弃还没有flush的缓存的内容，革除谬误并把它的输入传给参数中的writer // 当你想将缓存传给另外一个writer时有用 bufferedWriter.Reset(bufferedWriter) bytesAvailable = bufferedWriter.Available() if err != nil { log.Fatal(err) } log.Printf("Available buffer: %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("Available buffer: %d\n", bytesAvailable)}$ go run main.go2022/10/08 14:54:43 Bytes written: 32022/10/08 14:54:43 Bytes written: 162022/10/08 14:54:43 Bytes buffered: 192022/10/08 14:54:43 Available buffer: 40772022/10/08 14:54:43 Available buffer: 40962022/10/08 14:54:43 Available buffer: 8000偏移量写入
import "os" func writeAt(filename string) error { data := []byte{ 0x41, // A 0x73, // s 0x20, // space 0x20, // space 0x67, // g } f, err := os.OpenFile(filename, os.O_WRONLY, 0666) if err != nil{ return err } _, err = f.Write(data) if err != nil{ return err } replaceSplace := []byte{ 0x6F, // o 0x6E, // n } _, err = f.WriteAt(replaceSplace, 2) if err != nil{ return err } f.Close() return nil}3.6 读取最多N个字节
os.File提供了文件操作的基本功能， 而io、ioutil、bufio提供了额定的辅助函数。
package mainimport ( "os" "log")func main() { // 关上文件，只读 file, err := os.Open("test.txt") if err != nil { log.Fatal(err) } defer file.Close() // 从文件中读取len(b)字节的文件。 // 返回0字节意味着读取到文件尾了 // 读取到文件会返回io.EOF的error byteSlice := make([]byte, 16) bytesRead, err := file.Read(byteSlice) if err != nil { log.Fatal(err) } log.Printf("Number of bytes read: %d\n", bytesRead) log.Printf("Data read: %s\n", byteSlice)}3.7 读取正好N个字节
package mainimport ( "os" "log" "io")func main() { // Open file for reading file, err := os.Open("test.txt") if err != nil { log.Fatal(err) } // file.Read()能够读取一个小文件到大的byte slice中， // 然而io.ReadFull()在文件的字节数小于byte slice字节数的时候会返回谬误 byteSlice := make([]byte, 2) numBytesRead, err := io.ReadFull(file, byteSlice) if err != nil { log.Fatal(err) } log.Printf("Number of bytes read: %d\n", numBytesRead) log.Printf("Data read: %s\n", byteSlice)}3.8 读取至多N个字节
package mainimport ( "os" "log" "io")func main() { // 关上文件，只读 file, err := os.Open("test.txt") if err != nil { log.Fatal(err) } byteSlice := make([]byte, 512) minBytes := 8 // io.ReadAtLeast()在不能失去最小的字节的时候会返回谬误，但会把已读的文件保留 numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes) if err != nil { log.Fatal(err) } log.Printf("Number of bytes read: %d\n", numBytesRead) log.Printf("Data read: %s\n", byteSlice)}3.9 读取全副字节
package mainimport ( "os" "log" "fmt" "io/ioutil")func main() { file, err := os.Open("test.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("Data as hex: %x\n", data) fmt.Printf("Data as string: %s\n", data) fmt.Println("Number of bytes read:", len(data))}3.10 快读到内存
package mainimport ( "log" "io/ioutil")func main() { // 读取文件到byte slice中 data, err := ioutil.ReadFile("test.txt") if err != nil { log.Fatal(err) } log.Printf("Data read: %s\n", data)}3.11 应用缓存读
有缓存写也有缓存读。
缓存reader会把一些内容缓存在内存中。它会提供比os.File和io.Reader更多的函数,缺省的缓存大小是4096，最小缓存是16。
$ cat test.txt ABCBuffered string0lllllllllllllpackage mainimport ( "bufio" "fmt" "log" "os")func main() { // 关上文件，创立buffered reader file, err := os.Open("test.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("Peeked at 5 bytes: %s\n", byteSlice) // 读取，指针同时挪动 numBytesRead, err := bufferedReader.Read(byteSlice) if err != nil { log.Fatal(err) } fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice) // 读取一个字节, 如果读取不胜利会返回Error myByte, err := bufferedReader.ReadByte() if err != nil { log.Fatal(err) } fmt.Printf("Read 1 byte: %c\n", myByte) // 读取到分隔符，蕴含分隔符，返回byte slice dataBytes, err := bufferedReader.ReadBytes('\n') if err != nil { log.Fatal(err) } fmt.Printf("Read bytes: %s\n", dataBytes) // 读取到分隔符，蕴含分隔符，返回字符串 dataString, err := bufferedReader.ReadString('\n') if err != nil { log.Fatal(err) } fmt.Printf("Read string: %s\n", dataString) //这个例子读取了很多行，所以test.txt应该蕴含多行文本才不至于出错}$ go run main.goPeeked at 5 bytes: ABCBuRead 5 bytes: ABCBuRead 1 byte: fRead bytes: fered stringRead string: 03.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 fingerprinttype 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 mainimport ( "os" "log" "fmt" "bufio")func main() { file, err := os.Open("test.txt") if err != nil { log.Fatal(err) } scanner := bufio.NewScanner(file) // 缺省的分隔函数是bufio.ScanLines,咱们这里应用ScanWords。 // 也能够定制一个SplitFunc类型的分隔函数 scanner.Split(bufio.ScanWords) // scan下一个token. success := scanner.Scan() if success == false { // 呈现谬误或者EOF是返回Error err = scanner.Err() if err == nil { log.Println("Scan completed and reached EOF") } else { log.Fatal(err) } } // 失去数据，Bytes() 或者 Text() fmt.Println("First word found:", scanner.Text()) // 再次调用scanner.Scan()发现下一个token}$ cat test.txtAvScanner是bufio包下的类型,在解决文件中以分隔符分隔的文本时很有用。通常咱们应用换行符作为分隔符将文件内容分成多行。在CSV文件中，逗号个别作为分隔符。os.File文件能够被包装成bufio.Scanner，它就像一个缓存reader。咱们会调用Scan()办法去读取下一个分隔符，应用Text()或者Bytes()获取读取的数据。分隔符能够不是一个简略的字节或者字符，有一个非凡的办法能够实现分隔符的性能，以及将指针挪动多少，返回什么数据。如果没有定制的SplitFunc提供，缺省的ScanLines会应用newline字符作为分隔符，其它的分隔函数还包含ScanRunes和ScanWords,皆在bufio包中。BCBuffered string0lllllllllllll $ go run main.goFirst word found: AvScanner是bufio包下的类型,在解决文件中以分隔符分隔的文本时很有用。First word found: AvScanner是bufio包下的类型,在解决文件中以分隔符分隔的文本时很有用。4 压缩
4.1 打包(zip) 文件
// This example uses zip but standard library// also supports tar archivespackage mainimport ( "archive/zip" "log" "os")func main() { // 创立一个打包文件 outFile, err := os.Create("test.zip") if err != nil { log.Fatal(err) } defer outFile.Close() // 创立zip writer zipWriter := zip.NewWriter(outFile) // 往打包文件中写文件。 // 这里咱们应用硬编码的内容，你能够遍历一个文件夹，把文件夹下的文件以及它们的内容写入到这个打包文件中。 var filesToArchive = []struct { Name, Body string } { {"test.txt", "String contents of file"}, {"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) }}4.2 抽取(unzip) 文件
// This example uses zip but standard library// also supports tar archivespackage mainimport ( "archive/zip" "log" "io" "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) } } }}4.3 压缩文件
// 这个例子中应用gzip压缩格局，规范库还反对zlib, bz2, flate, lzwpackage mainimport ( "os" "compress/gzip" "log")func main() { outputFile, err := os.Create("test.txt.gz") if err != nil { log.Fatal(err) } 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.")}4.4 解压缩文件
// 这个例子中应用gzip压缩格局，规范库还反对zlib, bz2, flate, lzwpackage mainimport ( "compress/gzip" "log" "io" "os")func main() { // 关上一个gzip文件。 // 文件是一个reader,然而咱们能够应用各种数据源，比方web服务器返回的gzipped内容， // 它的内容不是一个文件，而是一个内存流 gzipFile, err := os.Open("test.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("unzipped.txt") if err != nil { log.Fatal(err) } defer outfileWriter.Close() // 复制内容 _, err = io.Copy(outfileWriter, gzipReader) if err != nil { log.Fatal(err) }}5 其它
5.1 临时文件和目录
ioutil提供了两个函数: TempDir() 和 TempFile()。
应用结束后，调用者负责删除这些临时文件和文件夹。
有一点益处就是当你传递一个空字符串作为文件夹名的时候，它会在操作系统的长期文件夹中创立这些我的项目（/tmp on Linux）。os.TempDir()返回以后操作系统的长期文件夹。
package mainimport ( "os" "io/ioutil" "log" "fmt")func main() { // 在零碎长期文件夹中创立一个长期文件夹 tempDirPath, err := ioutil.TempDir("", "myTempDir") if err != nil { log.Fatal(err) } fmt.Println("Temp dir created:", tempDirPath) // 在长期文件夹中创立临时文件 tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt") if err != nil { log.Fatal(err) } fmt.Println("Temp file created:", 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) }}5.2 通过HTTP下载文件
package mainimport ( "os" "io" "log" "net/http")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) 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)}5.3 哈希和摘要
package mainimport ( "crypto/md5" "crypto/sha1" "crypto/sha256" "crypto/sha512" "log" "fmt" "io/ioutil")func main() { // 失去文件内容 data, err := ioutil.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。
package mainimport ( "crypto/md5" "log" "fmt" "io" "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)}本文由mdnice多平台公布