(转)golang 读写文件的四种方式

原文:https://blog.csdn.net/whatday/article/details/103938124

读文件

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

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

  1.  
    func Read0() (string){
  2.  
    f, err := ioutil.ReadFile("file/test")
  3.  
    if err != nil {
  4.  
    fmt.Println("read fail", err)
  5.  
    }
  6.  
    return string(f)
  7.  
    }
  8.  
     

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

  1.  
    func Read1() (string){
  2.  
    //获得一个file
  3.  
    f, err := os.Open("file/test")
  4.  
    if err != nil {
  5.  
    fmt.Println("read fail")
  6.  
    return ""
  7.  
    }
  8.  
     
  9.  
    //把file读取到缓冲区中
  10.  
    defer f.Close()
  11.  
    var chunk []byte
  12.  
    buf := make([]byte, 1024)
  13.  
     
  14.  
    for {
  15.  
    //从file读取到buf中
  16.  
    n, err := f.Read(buf)
  17.  
    if err != nil && err != io.EOF{
  18.  
    fmt.Println("read buf fail", err)
  19.  
    return ""
  20.  
    }
  21.  
    //说明读取结束
  22.  
    if n == 0 {
  23.  
    break
  24.  
    }
  25.  
    //读取到最终的缓冲区中
  26.  
    chunk = append(chunk, buf[:n]...)
  27.  
    }
  28.  
     
  29.  
    return string(chunk)
  30.  
    //fmt.Println(string(chunk))
  31.  
    }
  32.  
     

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

  1.  
    //先从文件读取到file, 在从file读取到Reader中,从Reader读取到buf, buf最终追加到[]byte,这个排第三
  2.  
    func Read2() (string) {
  3.  
    fi, err := os.Open("file/test")
  4.  
    if err != nil {
  5.  
    panic(err)
  6.  
    }
  7.  
    defer fi.Close()
  8.  
     
  9.  
    r := bufio.NewReader(fi)
  10.  
    var chunks []byte
  11.  
     
  12.  
    buf := make([]byte, 1024)
  13.  
     
  14.  
    for {
  15.  
    n, err := r.Read(buf)
  16.  
    if err != nil && err != io.EOF {
  17.  
    panic(err)
  18.  
    }
  19.  
    if 0 == n {
  20.  
    break
  21.  
    }
  22.  
    //fmt.Println(string(buf))
  23.  
    chunks = append(chunks, buf...)
  24.  
    }
  25.  
    return string(chunks)
  26.  
    //fmt.Println(string(chunks))
  27.  
    }
  28.  
     

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

  1.  
    //读取到file中,再利用ioutil将file直接读取到[]byte中, 这是最优
  2.  
    func Read3() (string){
  3.  
    f, err := os.Open("file/test")
  4.  
    if err != nil {
  5.  
    fmt.Println("read file fail", err)
  6.  
    return ""
  7.  
    }
  8.  
    defer f.Close()
  9.  
     
  10.  
    fd, err := ioutil.ReadAll(f)
  11.  
    if err != nil {
  12.  
    fmt.Println("read to fd fail", err)
  13.  
    return ""
  14.  
    }
  15.  
     
  16.  
    return string(fd)
  17.  
    }
  18.  
     

读取速度比较

  1.  
    import (
  2.  
    "bufio"
  3.  
    "fmt"
  4.  
    "io"
  5.  
    "io/ioutil"
  6.  
    "os"
  7.  
    "time"
  8.  
    )
  9.  
     
  10.  
    func Read1() string {
  11.  
    f, err := ioutil.ReadFile("/root/test")
  12.  
    if err != nil {
  13.  
    fmt.Println("read fail", err)
  14.  
    }
  15.  
    return string(f)
  16.  
    }
  17.  
     
  18.  
    func Read2() string {
  19.  
    //获得一个file
  20.  
    f, err := os.Open("/root/test")
  21.  
    if err != nil {
  22.  
    fmt.Println("read fail")
  23.  
    return ""
  24.  
    }
  25.  
     
  26.  
    //把file读取到缓冲区中
  27.  
    defer f.Close()
  28.  
    var chunk []byte
  29.  
    buf := make([]byte, 1024)
  30.  
     
  31.  
    for {
  32.  
    //从file读取到buf中
  33.  
    n, err := f.Read(buf)
  34.  
    if err != nil && err != io.EOF {
  35.  
    fmt.Println("read buf fail", err)
  36.  
    return ""
  37.  
    }
  38.  
    //说明读取结束
  39.  
    if n == 0 {
  40.  
    break
  41.  
    }
  42.  
    //读取到最终的缓冲区中
  43.  
    chunk = append(chunk, buf[:n]...)
  44.  
    }
  45.  
     
  46.  
    return string(chunk)
  47.  
    //fmt.Println(string(chunk))
  48.  
    }
  49.  
     
  50.  
    func Read3() string {
  51.  
    fi, err := os.Open("/root/test")
  52.  
    if err != nil {
  53.  
    panic(err)
  54.  
    }
  55.  
    defer fi.Close()
  56.  
     
  57.  
    r := bufio.NewReader(fi)
  58.  
    var chunks []byte
  59.  
     
  60.  
    buf := make([]byte, 1024)
  61.  
     
  62.  
    for {
  63.  
    n, err := r.Read(buf)
  64.  
    if err != nil && err != io.EOF {
  65.  
    panic(err)
  66.  
    }
  67.  
    if 0 == n {
  68.  
    break
  69.  
    }
  70.  
    //fmt.Println(string(buf))
  71.  
    chunks = append(chunks, buf...)
  72.  
    }
  73.  
    return string(chunks)
  74.  
    //fmt.Println(string(chunks))
  75.  
    }
  76.  
     
  77.  
    func Read4() string {
  78.  
    f, err := os.Open("/root/test")
  79.  
    if err != nil {
  80.  
    fmt.Println("read file fail", err)
  81.  
    return ""
  82.  
    }
  83.  
    defer f.Close()
  84.  
     
  85.  
    fd, err := ioutil.ReadAll(f)
  86.  
    if err != nil {
  87.  
    fmt.Println("read to fd fail", err)
  88.  
    return ""
  89.  
    }
  90.  
     
  91.  
    return string(fd)
  92.  
    }
  93.  
     
  94.  
    func main() {
  95.  
    start := time.Now().UnixNano() / 1e6
  96.  
    Read1()
  97.  
    end := time.Now().UnixNano() / 1e6
  98.  
    fmt.Printf("Read1=%d,\n", end-start)
  99.  
    }

分别测试 read2 read3 read4

  1.  
    func main() {
  2.  
    start := time.Now().UnixNano() / 1e6
  3.  
    Read2()
  4.  
    end := time.Now().UnixNano() / 1e6
  5.  
    fmt.Printf("Read2=%d,\n", end-start)
  6.  
    }
  1.  
    func main() {
  2.  
    start := time.Now().UnixNano() / 1e6
  3.  
    Read3()
  4.  
    end := time.Now().UnixNano() / 1e6
  5.  
    fmt.Printf("Read3=%d,\n", end-start)
  6.  
    }
  1.  
    func main() {
  2.  
    start := time.Now().UnixNano() / 1e6
  3.  
    Read4()
  4.  
    end := time.Now().UnixNano() / 1e6
  5.  
    fmt.Printf("Read4=%d,\n", end-start)
  6.  
    }

输出结果

  1.  
    [root@localhost src]# ll -h /root | grep test
  2.  
    -rwxr-xr-x. 1 root root 136M Nov 7 19:20 test
  3.  
    [root@localhost src]# go build
  4.  
    [root@localhost src]# ./test
  5.  
    Read1=625,
  6.  
    [root@localhost src]# go build
  7.  
    [root@localhost src]# ./test
  8.  
    Read2=1313,
  9.  
    [root@localhost src]# go build
  10.  
    [root@localhost src]# ./test
  11.  
    Read3=1724,
  12.  
    [root@localhost src]# go build
  13.  
    [root@localhost src]# ./test
  14.  
    Read4=1057,

经过测试,这四种方式读的速度排名是:前者为优
方式一 > 方式四 > 方式二 > 方式三

写文件

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

  1.  
    func Write0() {
  2.  
    fileName := "file/test1"
  3.  
    strTest := "测试测试"
  4.  
     
  5.  
    var f *os.File
  6.  
    var err error
  7.  
     
  8.  
    if CheckFileExist(fileName) { //文件存在
  9.  
    f, err = os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
  10.  
    if err != nil{
  11.  
    fmt.Println("file open fail", err)
  12.  
    return
  13.  
    }
  14.  
    }else { //文件不存在
  15.  
    f, err = os.Create(fileName) //创建文件
  16.  
    if err != nil {
  17.  
    fmt.Println("file create fail")
  18.  
    return
  19.  
    }
  20.  
    }
  21.  
    //将文件写进去
  22.  
    n, err1 := io.WriteString(f, strTest)
  23.  
    if err1 != nil {
  24.  
    fmt.Println("write error", err1)
  25.  
    return
  26.  
    }
  27.  
    fmt.Println("写入的字节数是:", n)
  28.  
    }
  29.  
     

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

  1.  
    func Write1() {
  2.  
    fileName := "file/test2"
  3.  
    strTest := "测试测试"
  4.  
    var d = []byte(strTest)
  5.  
    err := ioutil.WriteFile(fileName, d, 0666)
  6.  
    if err != nil {
  7.  
    fmt.Println("write fail")
  8.  
    }
  9.  
    fmt.Println("write success")
  10.  
    }
  11.  
     

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

  1.  
    func Write2() {
  2.  
     
  3.  
    fileName := "file/test3"
  4.  
    strTest := "测试测试"
  5.  
    var d1 = []byte(strTest)
  6.  
     
  7.  
    f, err3 := os.Create(fileName) //创建文件
  8.  
    if err3 != nil{
  9.  
    fmt.Println("create file fail")
  10.  
    }
  11.  
    defer f.Close()
  12.  
    n2, err3 := f.Write(d1) //写入文件(字节数组)
  13.  
     
  14.  
    fmt.Printf("写入 %d 个字节n", n2)
  15.  
    n3, err3 := f.WriteString("writesn") //写入文件(字节数组)
  16.  
    fmt.Printf("写入 %d 个字节n", n3)
  17.  
    f.Sync()
  18.  
    }
  19.  
     

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

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

检查文件是否存在:

    1.  
      func CheckFileExist(fileName string) bool {
    2.  
      _, err := os.Stat(fileName)
    3.  
      if os.IsNotExist(err) {
    4.  
      return false
    5.  
      }
    6.  
      return true
    7.  
      }
    8.  
posted @   liujiacai  阅读(295)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
历史上的今天:
2019-03-10 (转)[Python 网络编程] makefile (三)
点击右上角即可分享
微信分享提示