Golang several ways to read and write files

With files in golang There are many ways, let's take a look.

(1) os module

Let's look at how to view file properties

package main

import (
    "fmt"
    "os"
)

func main() {
    //打开文件使用os.Open函数，会返回一个文件句柄和一个error
    file, err := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    if err != nil {
        fmt.Println("文件打开失败：",err)
    }

    //调用file.Stat()可以查看文件的信息，这是一个os.FileInfo对象
    info, err := file.Stat()
    //属性如下
    /*
    type FileInfo interface {
        Name() string       // 文件名
        Size() int64        // 文件的大小，按字节计算
        Mode() FileMode     // 文件的模式
        ModTime() time.Time // 修改时间
        IsDir() bool        // 是否是目录
        Sys() interface{}   // 数据源，一般不用管
    }
     */
    fmt.Println(info.Name()) // whiteblum.txt
    fmt.Println(info.Size()) // 183

    //有点类似于linux里面的，第一个-表示文本文件，后面的三个rw-表示可读可写不可执行。
    //分别是用户、用户所属组、其他组的权限
    fmt.Println(info.Mode()) // -rw-rw-rw-
    fmt.Println(info.ModTime()) // 2019-08-31 19:52:44.3146692 +0800 CST
    fmt.Println(info.IsDir()) // false
    fmt.Println(info.Sys())  // &{32 {2579124676 30760946} {2579124676 30760946} {2579124676 30760946} 0 183}
}

Read the contents of a file inside

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    if err != nil {
        fmt.Println("文件打开失败：",err)
    }
    //忘记说了，文件打开是要关闭的,调用defer函数即可
    defer file.Close()

    //此外file.Name()还可以拿到文件的所在路径，file.Fd()则是拿到文件的描述符
    fmt.Println(file.Name()) //D:\komeijisatori\src\day3\whiteblum.txt
    fmt.Println(file.Fd()) // 216

    //读取文件内容可以调用file.Read()方法，接收一个字节数组，返回一个int和error
    buf := make([]byte, 12)
    //此时文件的内容都会读到buf里面，n则是写入了多少个字节,n不会超过字节数组buf的长度
    n, err := file.Read(buf)
    
    //将写入的内容读取出来
    fmt.Println(string(buf[:n])) //白色相簿
}

我们注意到：当前只是读取了12个字节，并没有全部读取完。这是因为我们的buf长度只有12，我们可以将容量变得更大一些，但是到底要弄多大呢？这是一个未知数。弄小了一次读不完，要是弄大了，会浪费。因此最好的办法，不要一次就读完，而是循环读取，这样不就好了吗？一般的话，我们都将buf的长度设置为1024个字节，但由于我的文件比较小，所以就设置为12个字节

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    if err != nil {
        fmt.Println("文件打开失败：",err)
    }
    defer file.Close()

    buf := make([]byte, 12) // 存放文件内容的缓存，相当于中转站
    data := make([]byte, 0) // 用来存放文件内容，buf读取的内容都会写到data里面去

    for {
        //无限循环，不断读取
        n, err := file.Read(buf)
        // 什么时候文件读完呢？如果文件读完的话，那么err不为nil，而是io.EOF
        // 所以我们可以进行判断
        if err != nil {
            //如果err != nil说明出错了，但如果还等于io.EOF的话，说明读完了，因为文件读完，err也不为nil。直接break
            if err == io.EOF{
                break
            } else {
                //如果错误不是io.EOF的话，说明就真的在读取中出现了错误，直接panic出来
                panic(err)
            }
        }
        //此时文件内容写到buf里面去了，写了多少个呢？写了n个，那么我们再写到data里面去
        data = append(data, buf[: n]...)

        //我们来打印一下，每次写了多少个字节
        fmt.Printf("写入%d个字节\n", n)
        /*
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入12个字节
        写入6个字节
         */
    }

    //写完之后，我们来打印一下
    fmt.Println(string(data))
    /*
    白色相簿什么的，已经无所谓了。
    因为已经不再有歌，值得去唱了。
    传达不了的恋情，已经不需要了。
    因为已经不再有人，值得去爱了。
    */
}

So how do you use the os module to write to a file it?

package main

import (
    "fmt"
    "os"
)

func main() {
    //既然要写，那么就不能使用Open了，而是使用Create
    //Create会创建一个文件，如果存在会清空原有的内容
    file, err := os.Create(`D:\komeijisatori\src\day3\whiteblum.txt`)
    if err != nil {
        fmt.Println("文件创建失败：",err)
    }
    defer file.Close()
    //写入文件可以调用file.WriteString，或者file.Write方法
    //前者是写入字符，后者是写入字节。
    // 其实WriteString底层是将我们传入的字符串变成字节数组，然后还是调用Write方法
    //会有两个返回值，一个是我们写入的个数，一个是error
    n, err := file.WriteString("这是新写入的内容，原来的内容会丢失")
    //golang是按照字节算的，一个汉字占三个字节
    fmt.Println(n) // 51

    //再来读取一下看看，有没有写入
    file, err = os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    //直接将数组设置的大一些，一次读取完毕
    new_buf := make([]byte, 1024)
    n, _ = file.Read(new_buf)
    fmt.Println(string(new_buf[: n])) // 这是新写入的内容，原来的内容会丢失
}

In fact, both the Open or Create, the bottom is called OpenFile

package main

import (
    "fmt"
    "os"
)

func main() {
    // OpenFile接收三个参数
    // 1.文件名
    // 2.文件的模式,支持如下
    /*
    os.O_RDONLY: 以只读的方式打开
    os.O_WRONLY: 以只写的方式打开
    os.O_RDWR : 以读写的方式打开
    os.O_NONBLOCK: 打开时不阻塞
    os.O_APPEND: 以追加的方式打开
    os.O_CREAT: 创建并打开一个新文件
    os.O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限）
    os.O_EXCL: 如果指定的文件存在，返回错误
    os.O_SHLOCK: 自动获取共享锁
    os.O_EXLOCK: 自动获取独立锁
    os.O_DIRECT: 消除或减少缓存效果
    os.O_FSYNC : 同步写入
    os.O_NOFOLLOW: 不追踪软链接
     */
    // 3.权限，一般设置为0666，这在linux下有用，Windows下面没太大卵用

    // 以只写的方式打开，并且写入的时候，是以追加的形式写入
    file, _ := os.OpenFile(`D:\komeijisatori\src\day3\whiteblum.txt`,os.O_WRONLY|os.O_APPEND, 0666)

    _, _ = file.Write([]byte("\n这是新的内容，但是原来的内容还在"))

    //写入之后，我们再以只读方式打开
    file, _ = os.OpenFile(`D:\komeijisatori\src\day3\whiteblum.txt`,os.O_RDONLY, 0666)
    buf := make([]byte, 1024)
    n, _ := file.Read(buf)
    fmt.Println(string(buf[: n]))
    /*
    这是新写入的内容，原来的内容会丢失
    这是新的内容，但是原来的内容还在
     */
}

但是通常我们直接使用Open和Create函数

(2) bufio

bufio equivalent is encapsulated in a layer above the file handle os.OpenFile obtained, bufio, from the name can also be seen io is unbuffered.

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    file, _ := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)

    //使用bufio.NewReader进行一层包装
    reader := bufio.NewReader(file)
    //首先这个reader，可以像file一样，使用Read方法
    //然而reader还可是按照指定字符来读，比如我想一行一行读，就可以指定换行符来读
    for{
        //返回string和error
        s, err := reader.ReadString('\n') //表示每读到\n就停止
        //这里使用print，因为文件本身有换行符，println自带换行，所以使用print
        fmt.Print("读取一行：", s)
        /*
        读取一行：白色相簿什么的，已经无所谓了。
        读取一行：因为已经不再有歌，值得去唱了。
        读取一行：传达不了的恋情，已经不需要了。
        读取一行：因为已经不再有人，值得去爱了。
         */
        if err != nil {
            if err == io.EOF{
                break
            } else {
                panic(err)
            }
        }
    }
}

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "os"
)

func main() {
    file, _ := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)

    //除了NewReader，还有一个NewScanner
    scanner := bufio.NewScanner(file)
    for scanner.Scan(){
        //可以看到我们使用println打印，行与行之间没有空隙，说明scanner.Text()没有把换行符读进去。
        fmt.Println(scanner.Text())
        /*
        白色相簿什么的，已经无所谓了。
        因为已经不再有歌，值得去唱了。
        传达不了的恋情，已经不需要了。
        因为已经不再有人，值得去爱了。
         */
    }

    //但是这都是一行一行读的，我们可以写到缓存里面去
    //这个缓存使用bytes.Buffer{}来创建
    buf := bytes.Buffer{}
    file, _ = os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    scanner = bufio.NewScanner(file)
    for scanner.Scan(){
        //直接调用buf.WriteString即可
        buf.WriteString(scanner.Text())
        // 当然还可以使用buf.Write写入字节，同时也可以使用scanner.Bytes()得到字节。buf.Write(scanner.Bytes())
    }
    //可以调用buf.Bytes()拿到字节
    //也可以调用buf.String()拿到String
    fmt.Println(buf.String())  // 白色相簿什么的，已经无所谓了。因为已经不再有歌，值得去唱了。传达不了的恋情，已经不需要了。因为已经不再有人，值得去爱了。
    //因为没有读取换行符，所以是连在一起的

    //这里再提一下bytes.Buffer{}，这是一个非常方便的字节缓存。用来组合字符串非常方便
    buffer := bytes.Buffer{}
    buffer.WriteString("哈哈")
    buffer.WriteString("呱呱")
    buffer.Write([]byte("嘻嘻"))
    fmt.Println(buffer.String())  // 哈哈呱呱嘻嘻
    fmt.Println(buffer.Bytes()) // [229 147 136 229 147 136 229 145 177 229 145 177 229 152 187 229 152 187]

    //当然buffer也有ReadString，和Read方法
    s, _ := buffer.ReadString('\n')
    fmt.Println(s) // 哈哈呱呱嘻嘻

    buffer.WriteString("你胸大，你先说")
    b := make([]byte, 1024)
    n, _  := buffer.Read(b)
    fmt.Println(string(b[: n])) // 你胸大，你先说
}

(3) Module ioutil

ioutil is a very powerful module

package main

import (
    "fmt"
    "io/ioutil"
    "os"
)

func main() {
    file, _ := os.Open(`D:\komeijisatori\src\day3\whiteblum.txt`)
    // 直接将file丢进去，可以读取全部内容
    s, _ := ioutil.ReadAll(file)
    fmt.Println(string(s))
    /*
    白色相簿什么的，已经无所谓了。
    因为已经不再有歌，值得去唱了。
    传达不了的恋情，已经不需要了。
    因为已经不再有人，值得去爱了。
     */
    // 是不是很方便呢？其实还有更方便的
    //调用ReadFile，传入文件名直接得到字节数组和error。当然底层是使用了os.Open和ioutil.ReadAll
    s, _ = ioutil.ReadFile(`D:\komeijisatori\src\day3\whiteblum.txt`)
    fmt.Println(string(s))
    /*
    白色相簿什么的，已经无所谓了。
    因为已经不再有歌，值得去唱了。
    传达不了的恋情，已经不需要了。
    因为已经不再有人，值得去爱了。
     */
}

当然ioutil开可以写入文件

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
)

func main() {
    buf := bytes.Buffer{}
    buf.WriteString("明明是我先来的\n")
    buf.WriteString("为什么会变成这样呢\n")
    buf.WriteString("何でそんなに慣れてんだよ\n")
    buf.WriteString("雪菜と何度もキースしたんだよ")
    //传入filename，content，权限
    _ = ioutil.WriteFile(`D:\komeijisatori\src\day3\whiteblum.txt`, buf.Bytes(), 0666)

    //读取出来看看
    s, _ := ioutil.ReadFile(`D:\komeijisatori\src\day3\whiteblum.txt`)
    fmt.Println(string(s))
    /*
    明明是我先来的
    为什么会变成这样呢
    何でそんなに慣れてんだよ
    雪菜と何度もキースしたんだよ
     */
}

之前说ioutil很强大，是因为还有别的用处，比如读取目录

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    files, _ := ioutil.ReadDir(`C:\python37\Lib\site-packages\tornado`)
    //返回一个[]os.FileInfo和error
    for _, file := range files{
        if !file.IsDir(){
            fmt.Println(file.Name())
            /*
            __init__.py
            _locale_data.py
            auth.py
            autoreload.py
            concurrent.py
            curl_httpclient.py
            escape.py
            gen.py
            http1connection.py
            httpclient.py
            httpserver.py
            httputil.py
            ioloop.py
            iostream.py
            locale.py
            locks.py
            log.py
            netutil.py
            options.py
            process.py
            py.typed
            queues.py
            routing.py
            simple_httpclient.py
            speedups.cp37-win_amd64.pyd
            tcpclient.py
            tcpserver.py
            template.py
            testing.py
            util.py
            web.py
            websocket.py
            wsgi.py
             */
        }
    }
}