Go_文件操作

使用OS操作文件

读写示例

package main

import (
	"os"
	"fmt"
)

func main(){

	f, _ := os.OpenFile(`C:\Users\asus\Desktop\aa.txt`,os.O_WRONLY, 0777 )
	defer f.Close()
	f.Write([]byte("叫爸爸")) // 将字节写入文件中
	f1, _ := os.Open(`C:\Users\asus\Desktop\aa.txt`)
	f1.Close()
	var b =  make([]byte, 20)
	c,_ := f1.Read(b) // 读取文件字节至b切片中
	fmt.Println(c)
	fmt.Println(b)
	str := string(b)
	fmt.Println(str)
}

相关常量及File的方法

先介绍打开文件的方法参数及返回值

func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0) // 只读
}

func OpenFile(name string, flag int, perm FileMode) (*File, error) {
    pass
}

// name  文件名
// flag  打开方式
    //模式常量/ 可以使用|隔开来实现两个
    //os.O_WRONLY: 只写
    //os.O_CREATE: 创建
    //os.O_RDONLY : 只读
    //os.O_RDWR : 读写
    //os.O_TRUNC : 清空

//perm  linux中的权限

File结构体的方法

//写入一个slice,返回写的个数,错误信息,通过File的内存地址调用
func (file *File)Write(b []byte)(n int,err Error)
//从slice的某个位置开始写入,返回写的个数,错误信息,通过File的内存地址调用
func (file *File)WriteAt(b []byte,off int64)(n int,err Error)
//写入一个字符串,返回写的个数,错误信息,通过File的内存地址调用
func (file *File) WriteString(s string)(ret int,err Error)

//读取一个slice,返回读的个数,错误信息,通过File的内存地址调用
func (file *File) Read(b []byte)(n int, err Error)
//从slice的某个位置开始读取,返回读到的个数,错误信息,通过File的内存地址调用
func (file *File) ReadAt(b []byte,off int64)(n int,err Error)

os下的其他方法　

// 打开两个文件, 拷贝
func Copy(dst Writer, src Reader) (written int64, err error) {}

// 创建文件
func Create(name string) (*File, error) {} // 内部也是OpenFile

// Truncate文件
// 裁剪一个文件到100个字节。
// 如果文件本来就少于100个字节，则文件中原始内容得以保留，剩余的字节以null字节填充。
func Truncate(name string, size int64) error {}

//得到文件信息
// 如果文件不存在，则返回错误
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())

// 重命名和移动
originalPath := "test.txt"
newPath := "test2.txt"
err := os.Rename(originalPath, newPath)
if err != nil {
      log.Fatal(err)
}

// 删除文件
err := os.Remove("test.txt")
if err != nil {
    log.Fatal(err)
}

// 改变权限
// 使用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)
}


// 跳转到文件制定位置
 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)

　　

ioutil包

写文件

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

读文件

// ioutil.ReadAll()会读取reader(r)的每一个字节，然后把字节slice返回。
func ReadAll(r io.Reader) ([]byte, error) {} 

// 快速读到内存
func ReadFile(filename string) ([]byte, error) {}

使用bufio读写文件

bufio 用来帮助处理 I/O 缓存。 我们将通过一些示例来熟悉其为我们提供的：Reader, Writer and Scanner 等一系列功能

写文件

// func NewWriter(w io.Writer) *Writer {}  w是一个接口

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

// 写字符串到buffer
// 也可以使用 WriteRune() 和 WriteByte()   
bytesWritten, err = bufferedWriter.WriteString(
    "Buffered string\n",
)

// 写内存buffer到硬盘
bufferedWriter.Flush()

// 检查缓存中的字节数
unflushedBufferSize := bufferedWriter.Buffered()
log.Printf("Bytes buffered: %d\n", unflushedBufferSize)
 
// 还有多少字节可用（未使用的缓存大小）
bytesAvailable := bufferedWriter.Available()

读文件

// 打开文件，创建buffered reader
file, err := os.Open(`C:\Users\asus\Desktop\aa.txt`)
if err != nil {
	log.Fatal(err)
}
bufferedReader := bufio.NewReader(file)

// 重点一, 读取到分隔符，包含分隔符，返回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)


// 得到字节，当前指针不变seek
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)