go 文件读写

go 文件读写有很多方式

ioutil读文件

package main

import (
    "io/ioutil"
    "fmt"
)

func main() {
    data,err := ioutil.ReadFile("a.txt")  #这里返回的data是一个字节切片
    if err!=nil{
        fmt.Println("File reading error", err)
    }
    fmt.Println(string(data))
}

ioutil写文件

package main

import (
    "io/ioutil"
)

func main() {
    content := "hello world!"
    ioutil.WriteFile("a.txt",[]byte(content),)  //如果文件a.txt已经存在那么会忽略权限参数，清空文件内容。文件不存在会创建文件赋予权限
}

使用os包打开文件

//open函数 func Open(name string) (file *File, err error)
Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。
package main

import (
    _"io/ioutil"
    "os"
    "fmt"
)
func main() {
    f,_ := os.Open("a.txt")
    defer f.Close()
    data := make([]byte, )
    count,_ :=f.Read(data)
    fmt.Print(string(data[:count]))
}
//openfile函数
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式FileMode（如0666,即可读写，但是不可执行）
打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。
OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式FileMode（如0666,即可读写，但是不可执行）
打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。
参数flag可以结合使用：
os.O_WRONLY | os.O_CREATE | O_EXCL     //如果已经存在，则失败
os.O_WRONLY | os.O_CREATE              //如果已经存在，会覆盖写，不会清空原来的文件，而是从头直接覆盖写
os.O_WRONLY | os.O_CREATE | os.O_APPEND //如果已经存在，则在尾部添加写
参数perm：
linux中的权限rwx分别对应4  ，相加的值为7。如0666,即可读写，但是不可执行
package main

import (
    _"io/ioutil"
    "os"
    "fmt"
)
func main() {
    f,_ := os.OpenFile("a.txt",os.O_RDWR |os.O_APPEND,)//读写模式打开，写入追加
    defer f.Close()
    add_data :="this is add"
    num,_:=f.Write([]byte(add_data))
    fmt.Println(num)

    data := make([]byte, )
    count,err :=f.Read(data)
    if err!=nil{
        fmt.Println(err)  #这里会返回EOF错误，因为写入完毕后文件指针在最末尾，所以读取的时候是读不到内容的，需要重新打开一下这个文件
    }
    fmt.Print(string(data[:count]))
}

将文件绑定在二进制文件中

packr 会把静态文件（例如 .txt 文件）转换为 .go 文件，接下来，.go 文件会直接嵌入到二进制文件中。packer 非常智能，在开发过程中，可以从磁盘而非二进制文件中获取静态文件。在开发过程中，当仅仅静态文件变化时，可以不必重新编译。

package main

import (
    "fmt"

    "github.com/gobuffalo/packr"
)

func main() {
    box := packr.NewBox("../a.txt")
    data := box.String("test.txt")
    fmt.Println("Contents of file:", data)
}

逐行读取文件

package main

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

func main() {
    //fptr := flag.String("fpath", "test.txt", "file path to read from")
    //flag.Parse()

    f, err := os.Open(“a.txt”)   //因为bufio需要的是一个*os.File类型，所以我们换个方式读取，稍后再介绍一下
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err = f.Close(); err != nil {
        log.Fatal(err)
    }
    }()
    s := bufio.NewScanner(f)
    for s.Scan() {
        fmt.Println(s.Text())
    }
    err = s.Err()
    if err != nil {
        log.Fatal(err)
    }
}

分块读取文件

当文件非常大时，尤其在 RAM 存储量不足的情况下，把整个文件都读入内存是没有意义的。更好的方法是分块读取文件。这可以使用 bufio包来完成。

package main

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

func main() {
    //fptr := flag.String("fpath", "test.txt", "file path to read from")
    //flag.Parse()

    f, err := os.Open("a.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err = f.Close(); err != nil {
            log.Fatal(err)
        }
    }()
    r := bufio.NewReader(f)
    b := make([]byte, )
    for {
        _, err := r.Read(b)
        if err != nil {
            fmt.Println("Error reading file:", err)
            break
        }
        fmt.Println(string(b))
    }
}