Golang file 操作

概述

这里主要简单介绍了一下在 Go 中，file 的操作。

image

简单的分为：读,写,其他,三部分

首先先说 其他部分 （创建，截取，复制，下载，hash）

我自己定义了一个检查错误的方法，很多地方会用到, 非常简单，如下：

func check(err error){
    if err != nil {
        panic(err)
    }
}

创建

newfile, err := os.Create(writerfilename) // 给定一个文件名称
check(err)

会调用 os 包的 Create 方法，给定一个文件名称即可。

截取

func truncatefile() {
    infor, _ := os.Stat(writerfilename) // 可获取文件的信息
    fmt.Printf("origin Size %v \n",infor.Size()) // 查看文件大小
    err := os.Truncate(writerfilename, 19) // 从头截取到19位
    check(err)
    infor, _ = os.Stat(writerfilename)
    fmt.Printf("changed Size %v",infor.Size())
}

这里主要看文件大小，即可看到文件发生的变化，这里的19，是按照 byte 方式计算的。

复制

func copyfile(){
    /*
    writerfilename: 文件名称
    flag： 这里可以指定文件是读还是写入等（可参考下面的资料）
    FileMode： 其实是一个权限值 就像 777，666 权限一样
    */
    // os.OpenFile(writerfilename, os.O_WRONLY,0666) 
    
    originFile, err := os.Open(writerfilename)
    check(err)
    defer originFile.Close()

    newFile, err := os.Create(copy_file)
    check(err)
    defer newFile.Close()

    bytesWritten, err := io.Copy(newFile, originFile) // 把原来文件的内容拷贝到新文件中
    check(err)
    fmt.Print(bytesWritten)
}

flg 的取值可以参考下面的枚举

const (
    // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
    O_RDONLY int = syscall.O_RDONLY // open the file read-only.
    O_WRONLY int = syscall.O_WRONLY // open the file write-only.
    O_RDWR   int = syscall.O_RDWR   // open the file read-write.
    // The remaining values may be or'ed in to control behavior.
    O_APPEND int = syscall.O_APPEND // append data to the file when writing.
    O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
    O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
    O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
    O_TRUNC  int = syscall.O_TRUNC  // if possible, truncate file when opened.
)

downloadFile

func downFile(){
    url := "http://www.cycript.org/"
    response, err := http.Get(url)
    check(err)
    defer response.Body.Close()

    downFile := "file/downFile.html"
    file, err := os.Create(downFile)
    check(err)
    w, err := io.Copy(file, response.Body)
    check(err)
    fmt.Print(w)
}

代码也很简单，就是给定一个url，拿到body值，把buffer拷贝到新建的文件中即可。

hash

func hash(){
    bytes, err := ioutil.ReadFile(writerfilename)
    check(err)
    fmt.Printf("sha1.sum: %x\n", sha1.Sum(bytes))
    fmt.Printf("sha256.sum: %x\n", sha256.Sum256(bytes))
    fmt.Printf("sha512.sum: %x\n", sha512.Sum512(bytes))
    fmt.Printf("md5.sum: %x\n", md5.Sum(bytes))
}

这些都是内置的函数，直接使用即可，也很直观方便。

写入（writer）

写入其实也很简单，也分为 file ioutil bufio 三种方式

首先不管哪种方式，都要打开文件

open

file, err := os.OpenFile(
        filename,
        os.O_WRONLY,
        0666)
    check(err)
    defer file.Close()

file 写入

byteSlice` 是一个`byte`切片
1. file.WriteAt(byteSlice, 3) // 指定位置插入切片的值
2. file.Write(byteSlice) // 从头插入 len(byteSlice) 大小位
3. file.WriteString(str) // 也是从头开始插入 len(str) 长度位

ioutil

// Quick Write to File
err = ioutil.WriteFile(filename, byteSlice, 0666)
check(err)

快速插入的一种方式，给定一个大小，给定一个全选值即可。

bufio

1. bufferWrite.Write([]byte) //使用buffer 写入一个切片数据
2. bufferWrite.WriteString(str) // 写入一个字符

byteSlice := []byte{}
for i := 0; i<4092; i++ {
    byteSlice  = append(byteSlice, byte('c'))
}
    
bufferWrite := bufio.NewWriter(file)
rs, err := bufferWrite.Write(byteSlice)//bufferWrite.WriteString("今天是圣诞节")
check(err)
fmt.Print(rs)

值得注意的是buffer默认大小空间是 4096 ,当数据多的时候，系统会自己分配更大的空间来存储数据。

使用 Available() 可查看还可以填充多少数据

使用 Buffered 查看已经使用了多少数据

例如：我上面创建了一个大小位4092的byteSlice，写入到文件，那么使用 Available() 可以看到还剩余4个byte。

最后， bufferWrite.Reset(bufferWrite) reset 函数可以重置还未进过 flush 到磁盘的数据, 也就是说在调用了一系列的 buffer 插入数据后，必须使用 Flush() 写入数据到磁盘，不然他们都是在 buffer 里面的，而在未使用 Flush() 方法之前， buffer 里面的数据是可以 Reset 的。

读（Reader）

其实读是很简单的，不要看思维导图那么多，其实都大同小异。

func main() {
    file, err := os.Open(filename)
    check(err)

    defer file.Close()

    infor, err := file.Stat()
    check(err)

    // file
    byteSlice := make([]byte, infor.Size())
    rs, err := file.Read(byteSlice)
    check(err)
    fmt.Printf("reade data：%s \n", byteSlice)
    fmt.Printf("byte reader：%d \n", rs)

    // io
    //bufSlice := make([]byte, infor.Size())
    //rs, err := io.ReadFull(file, bufSlice)
    //check(err)
    //fmt.Printf("reader buf data: \n%s \n", bufSlice)
    //fmt.Printf("buf data: %d \n", rs)

    // io
    //byteSlice := make([]byte, 8)
    //min := 8
    //rs, err := io.ReadAtLeast(file, byteSlice, min)
    //fmt.Printf("reader buf data: \n%s \n", byteSlice)
    //fmt.Printf("buf data: %d \n", rs)

    // io & ioutil
    /*
        ioutil.ReadFile(filename) 快速读取一个文件的内容
        ioutil.ReadAll(file)    使用 io.Reader 读取
    */
    //bytes, err := ioutil.ReadFile(filename) // ioutil.ReadAll(file)
    //check(err)
    //fmt.Printf("reader buf data: \n%s \n", bytes)
    //fmt.Printf("buf data: %d \n", len(bytes))

    // buffer reader
    // bufio
    //bufferReader := bufio.NewReader(file) // bufio.NewReaderSize(file, 10)

    // Read
    //bufferSlice := make([]byte, infor.Size())
    //rs, err := bufferReader.Read(bufferSlice)
    //check(err)
    //fmt.Printf("%s", bufferSlice)
    //fmt.Printf("%d", rs)

    // peek
    //bytes, err := bufferReader.Peek(int(infor.Size()))
    //check(err)
    //fmt.Printf("%s", bytes)
    //fmt.Printf("%d", len(bytes))

    // Read 1 Byte
    //byte, err := bufferReader.ReadByte()
    //check(err)
    //fmt.Printf("reader 1 byte %c", byte)

    // ReadBytes return slice
    //bytes, err := bufferReader.ReadBytes('q')
    //check(err)
    //fmt.Printf("reader buf data: \n%s \n", bytes)
    //fmt.Printf("buf data: %d \n", len(bytes))

    // ReadString return string
    //bytes, err := bufferReader.ReadString('q')
    //check(err)
    //fmt.Printf("reader buf data: \n%v \n", bytes)
    //fmt.Printf("buf data: %d \n", len(bytes))

    // NewScanner
    //scanner := bufio.NewScanner(file)
    //for scanner.Scan() {
    //  fmt.Print(scanner.Text())
    //  fmt.Println()
    //}
}

值得注意的是 NewScanner 是读取buffer里面的数据，先读取到buffer中，然后使用 Scan() 方法来判断是否可以继续读取，然后来 使用 Text() 方法去值的

代码