golang 文件操作

sunnyJam

2020-05-04

Go官方库的文件操作分散在多个包中，比如os、ioutil、io包，强烈推荐你阅读一下。

原文: Working with Files in Go, 作者: NanoDano

基本操作

创建空文件

package main
import (
	"log"
	"os"
)

func main() {
    // 打开一个空的文件描述符
	newFile, err := os.Create("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	log.Println(newFile)
	_ = newFile.Close()
}

Truncate文件

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

获取文件信息

package main
import (
	"fmt"
	"log"
	"os"
)

func main() {
	// 如果文件不存在，则返回错误
	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())
}

重命名、删除、复制文件

package main

import (
	"io"
	"log"
	"os"
)
func main() {

	// rename
	originalPath := "test.txt"
	newPath := "test2.txt"
	err := os.Rename(originalPath, newPath)
	if err != nil {
		log.Fatal(err)
	}

	// remove
	err = os.Remove("test2.txt")
	if err != nil {
		log.Fatal(err)
	}

	// Copy
	Copy()
}

func Copy() {
	// TODO: copy
	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)
	}
}

func Copy2() {
	srcFile, err := os.Open(srcFileName)

	if err != nil {
		fmt.Printf("open file err = %v\n", err)
		return
	}

	defer srcFile.Close()

	//通过srcFile，获取到Reader
	reader := bufio.NewReader(srcFile)

	//打开dstFileName
	dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("open file err = %v\n", err)
		return
	}

	writer := bufio.NewWriter(dstFile)
	defer func() {
		writer.Flush() //把缓冲区的内容写入到文件
		dstFile.Close()

	}()

	io.Copy(writer, reader)
}

打开和关闭文件

下面的属性可以单独使用，也可以组合使用。
组合使用时可以使用 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的方式打开

package main
import (
	"log"
	"os"
)
func main() {
	// 简单地以只读的方式打开。下面的例子会介绍读写的例子。
	file, err := os.Open("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	file.Close()

	// OpenFile提供更多的选项。
	file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
	if err != nil {
		log.Fatal(err)
	}
	file.Close()
}

检查文件是否存在

package main
import (
	"log"
	"os"
)
var (
	fileInfo *os.FileInfo
	err      error
)
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)
}

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

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 号对应多个文件名，则称这些文件为硬链接。换言之，硬链接就是同一个文件使用了多个别名

什么是软链接？？

它不直接指向硬盘中的相同的地方，而是通过名字引用其它文件。删除软链接并不影响被指向的文件，但若被指向的原文件被删除，则相关软连接被称为死链接

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

判断文件权限

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.")
		}
	}
	// TODO: how to
	switch fileInfo.Mode().String() {
	}
}

读写文件

写文件

package main
import (
	"log"
	"os"
)
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)
    
    // 写文件字符串到文件
	// bytesWritten, err := file.WriteString("string")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Wrote %d bytes.", bytesWritten)
}

快速写文件

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

package main
import (
	"io/ioutil"
	"log"
)
func main() {
	err := ioutil.WriteFile("test.txt", []byte("Hi\n"), 0666)
	if err != nil {
		log.Fatal(err)
	}
}

使用缓存写

bufio包提供了带缓存功能的writer，所以你可以在写字节到硬盘前使用内存缓存。当你处理很多的数据很有用，因为它可以节省操作硬盘I/O的时间。在其它一些情况下它也很有用，比如你每次写一个字节，把它们攒在内存缓存中，然后一次写入到硬盘中，减少硬盘的磨损以及提升性能。

package main
import (
	"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",
	)
    //  writebyte
	// err = bufferedWriter.WriteByte(
	//   ‘z‘,
	// )

	// writerune
	// _, err = bufferedWriter.WriteRune(
	//	‘中‘,
	// )
	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)
}

读取最多N个字节

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

package main
import (
	"log"
	"os"
)
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)
}

读取至少N字节

package main
import (
   "io"
   "log"
   "os"
)
func main() {
   // 打开文件，只读
   file, err := os.Open("test.txt")
   if err != nil {
      log.Fatal(err)
   }
   byteSlice := make([]byte, 512)
   minBytes := 8
   // io.ReadAtLeast()在不能得到最小的字节的时候会返回错误(unexpected EOF)，但会把已读的文件保留
   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)
}

读取全部字节

package main
import (
   "fmt"
   "io/ioutil"
   "log"
   "os"
)
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))
}

快读到内存

package main
import (
	"io/ioutil"
	"log"
)
func main() {
	// 读取文件到byte slice中
	data, err := ioutil.ReadFile("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Data read: %s\n", data)
}

使用缓存读

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

TODO: 使用场景

package main

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

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应该包含多行文本才不至于出错
}

按行读取

package main

import (
	"bufio"
	"log"
	"os"
)
func main() {
	file, err := os.Open("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	scanner := bufio.NewScanner(file)
	// 缺省的分隔函数是bufio.ScanLines,我们这里使用ScanWords
	scanner.Split(bufio.ScanLines)
	for scanner.Scan() {
		log.Print(scanner.Text())
	}
}