网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang文件读写

2020-06-10 04:12:14 admin 597

### **参考**

> [Go实战--
> golang中读写文件的几种方式](https://link.jianshu.com?t=http%3A%2F%2Fblog.csdn.net%2Fwangshubo1989%2Farticle%2Fdetails%2F74777112)

### **读文件**

读取的文件放在file/test：也就是file包下的test这个文件，里面写多一点文件

* 读文件方式一：利用ioutil.ReadFile直接从文件读取到[]byte中

func Read0()  (string){
        f, err := ioutil.ReadFile("file/test")
        if err != nil {
            fmt.Println("read fail", err)
        }
        return string(f)
    }

* 读文件方式二：先从文件读取到file中，在从file读取到buf, buf在追加到最终的[]byte

func Read1()  (string){
        //获得一个file
        f, err := os.Open("file/test")
        if err != nil {
            fmt.Println("read fail")
            return ""
        }
    
        //把file读取到缓冲区中
        defer f.Close()
        var chunk []byte
        buf := make([]byte, 1024)
    
        for {
            //从file读取到buf中
            n, err := f.Read(buf)
            if err != nil && err != io.EOF{
                fmt.Println("read buf fail", err)
                return ""
            }
            //说明读取结束
            if n == 0 {
                break
            }
            //读取到最终的缓冲区中
            chunk = append(chunk, buf[:n]...)
        }
    
        return string(chunk)
        //fmt.Println(string(chunk))
    }

* 读文件方式三：先从文件读取到file, 在从file读取到Reader中，从Reader读取到buf, buf最终追加到[]byte

//先从文件读取到file, 在从file读取到Reader中，从Reader读取到buf, buf最终追加到[]byte，这个排第三
    func Read2() (string) {
        fi, err := os.Open("file/test")
        if err != nil {
            panic(err)
        }
        defer fi.Close()
    
        r := bufio.NewReader(fi)
        var chunks []byte
    
        buf := make([]byte, 1024)
    
        for {
            n, err := r.Read(buf)
            if err != nil && err != io.EOF {
                panic(err)
            }
            if 0 == n {
                break
            }
            //fmt.Println(string(buf))
            chunks = append(chunks, buf...)
        }
        return string(chunks)
        //fmt.Println(string(chunks))
    }

* 读文件方式四：读取到file中，再利用ioutil将file直接读取到[]byte中

//读取到file中，再利用ioutil将file直接读取到[]byte中, 这是最优
    func Read3()  (string){
        f, err := os.Open("file/test")
        if err != nil {
            fmt.Println("read file fail", err)
            return ""
        }
        defer f.Close()
    
        fd, err := ioutil.ReadAll(f)
        if err != nil {
            fmt.Println("read to fd fail", err)
            return ""
        }
    
        return string(fd)
    }

#### **读取速度比较**

经过我的测试，这四种方式读的速度排名是：前者为优  
方式四 > 方式一 > 方式三 > 方式四

###  **写文件**

* 写文件方式一：使用 io.WriteString 写入文件

func Write0()  {
        fileName := "file/test1"
        strTest := "测试测试"
    
        var f *os.File
        var err error
    
        if CheckFileExist(fileName) {  //文件存在
            f, err = os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
            if err != nil{
                fmt.Println("file open fail", err)
                return
            }
        }else {  //文件不存在
            f, err = os.Create(fileName) //创建文件
            if err != nil {
                fmt.Println("file create fail")
                return
            }
        }
        //将文件写进去
        n, err1 := io.WriteString(f, strTest)
        if err1 != nil {
            fmt.Println("write error", err1)
            return
        }
        fmt.Println("写入的字节数是：", n)
    }

* 写文件方式二：使用 ioutil.WriteFile 写入文件

func Write1()  {
        fileName := "file/test2"
        strTest := "测试测试"
        var d = []byte(strTest)
        err := ioutil.WriteFile(fileName, d, 0666)
        if err != nil {
            fmt.Println("write fail")
        }
        fmt.Println("write success")
    }

* 写文件方式三：使用 File(Write,WriteString) 写入文件

func Write2()  {
    
        fileName := "file/test3"
        strTest := "测试测试"
        var d1 = []byte(strTest)
    
        f, err3 := os.Create(fileName) //创建文件
        if err3 != nil{
            fmt.Println("create file fail")
        }
        defer f.Close()
        n2, err3 := f.Write(d1) //写入文件(字节数组)
    
        fmt.Printf("写入 %d 个字节n", n2)
        n3, err3 := f.WriteString("writesn") //写入文件(字节数组)
        fmt.Printf("写入 %d 个字节n", n3)
        f.Sync()
    }

* 写文件方式四：使用 bufio.NewWriter 写入文件

func Write3()  {
        fileName := "file/test3"
        f, err3 := os.Create(fileName) //创建文件
        if err3 != nil{
            fmt.Println("create file fail")
        }
        w := bufio.NewWriter(f) //创建新的 Writer 对象
        n4, err3 := w.WriteString("bufferedn")
        fmt.Printf("写入 %d 个字节n", n4)
        w.Flush()
        f.Close()
    }

* 检查文件是否存在：

func CheckFileExist(fileName string) bool {
        _, err := os.Stat(fileName)
        if os.IsNotExist(err) {
            return false
        }
        return true
    }

### **注意事项**

* 本文参考较大，如有侵权，请私信我处理，谢谢
  * 写文件的几种方式没有经过比较，如果有比较的话，也可以评论此篇文章告知我结果，谢谢

转载文章，原文链接： Golang文件读写

关键字词golang 读写

分享到：

上一篇：Golang网络请求

下一篇：Golang 运维脚本

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang文件读写

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang文件读写

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

admin 1年前