9.2 Go file IO operations

9.2 Go file IO operations

1.1.1. Bufio package

IO write operation with a buffer, for reading and writing files, keyboard input and reading

func main() {
    //NewReader返回一个结构体对象指针
    reader := bufio.NewReader(os.Stdin)
    //ReaderLine返回字节切片
    data, _, _ := reader.ReadLine()
    fmt.Printf("data类型：%T\n  数值：%v\n", data, data)
    //用string()内置函数强转切片为stirng
    str := string(data)
    fmt.Printf("data类型：%T\n  数值：%v\n", str, str)
}

Case Results

yugoMBP:day01 yuchao$ go run demo01_variable.go 
妖怪,放开我爷爷
data类型：[]uint8
  数值：[229 166 150 230 148 190 229 188 128 230 136 145 231 136 183 231 136 183]
data类型：string
  数值：妖放开我爷爷

1.1.2. File read and write

Mainly used for saving data files, such as pictures, videos, music, documents and so on.

Input and output program stream.

流：    指数据源(文件)和程序(内存)之间传输的路径
输入流：    数据从文件到内存的路径
输出流：    数据从内存到文件的路径

1.2. os.File

os.File encapsulates all of the files related operations.

//File是一个结构体
type File struct{
    //内涵隐藏或非导出字段
}

1.3 Open / close the file

Use functions and methods

//打开文件，返回文件句柄指针
func Open(name string)(file *File,err error)

func (*File)Close()error
//Close关闭文件f，文件此时无法读写。

Open, close the file, example

package main

import (
    "fmt"
    "os"
)

func main() {
    //打开文件，获取文件句柄
    file, err := os.Open("/Users/yuchao/go/src/gostudy/gobook/mygolang.txt")
    if err != nil {
        fmt.Println("打开文件出错了：", err)
    }
    //file文件句柄就是一个 指针类型
    fmt.Printf("文件句柄类型：%T  值：%v\n ", file, file)
    //打开文件，注意要释放，关闭文件资源
    err = file.Close()
    if err != nil {
        fmt.Println("出错了", err)
    }
}

Only read text

package main

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

func main() {
    //只读的方式打开文本
    file, err := os.Open("filepath")
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n')
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        fmt.Println(line)
    }
}

1.4. Os.OpenFile write to file

Go for the standard package os.OpenFile function to open a file, you can specify parameters, file permissions, file names, and so on.

Operating successfully returned the file handle.

func OpenFile(name string, flag int, perm FileMode) (*File, error)
//参数解析
name string   文件名，路径
flag int   文件打开模式
perm FileMode   unix文件权限

Open the file mode parameter annotation (Source parameter OpenFile function in)

打开标记：
O_RDONLY：只读模式(read-only)
O_WRONLY：只写模式(write-only)
O_RDWR：读写模式(read-write)
O_APPEND：追加模式(append)
O_CREATE：文件不存在就创建(create a new file if none exists.)
O_EXCL：与 O_CREATE 一起用，构成一个新建文件的功能，它要求文件必须不存在(used with O_CREATE, file must not exist)
O_SYNC：同步方式打开，即不使用缓存，直接写入硬盘
O_TRUNC：打开并清空文件
文件权限（unix权限位）：只有在创建文件时才需要，不需要创建文件可以设置为 0。os库虽然提供常量，一般直接写数字，如0664。
如果你需要设置多个打开标记和unix权限位，需要使用位操作符"|"

Parsing bufio

bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。

Create a file examples

package main

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

func main() {

    filePath := "/Users/yuchao/hello.txt"
    //O_WRONLY：只写模式(write-only)
    //O_CREATE：文件不存在就创建
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("打开文件出错了：%v\n", err)
        return
    }
    defer file.Close() //及时关闭文件句柄，防止内存泄露
    str := "你好，我是够浪\n" //定义字符串
    //写入数据
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString(str)
    }
    writer.Flush() //将缓冲区的数据，写入到磁盘文件中
}

Overwrite file contents

package main

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

func main() {
    //打开文件，覆盖原有数据
    //写入新数据，每天多努力一点，你会发现你更适合加班
    filePath := "/Users/yuchao/hello.txt"
    //O_WRONLY：只写模式(write-only)
    //O_TRUNC：打开并清空文件
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v\n", err)
        return
    }
    //关闭文件句柄
    defer file.Close()
    //写入新数据
    str := "每天多努力一点，你会发现你更适合加班\n"
    //写入携带缓存的 *Writer
    writer := bufio.NewWriter(file)
    //循环写入5条数据
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    /*
            writer是携带缓存的，因此调用writerString方法，
        其实内容是先写入到缓存中，必须调用flush，将缓冲的数据写入到文件中
    */
    writer.Flush()
}

Open the file already exists, 追加write to

package main

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

func main() {
    filePath := "/Users/yuchao/hello.txt"
    //O_WRONLY：只写模式(write-only)
    //O_APPEND：追加模式(append)
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v\n", err)
        return
    }
    //关闭文件句柄
    defer file.Close()
    //写入新数据
    str := "真的吗？那我一定要好好加班\n"
    //写入携带缓存的 *Writer
    writer := bufio.NewWriter(file)
    //循环写入5条数据
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    /*
            writer是携带缓存的，因此调用writerString方法，
        其实内容是先写入到缓存中，必须调用flush，将缓冲的数据写入到文件中
    */
    writer.Flush()
}

Open an existing file, 读取the original content displayed on the terminal, and 追加5 "加班万岁".

package main

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

func main() {
    //打开一个已有文件，`读取`出原本的内容显示在终端，并且`追加`5句`"加班万岁"`。
    filePath := "/Users/yuchao/hello.txt"
    //O_WRONLY：只写模式(write-only)
    //O_APPEND：追加模式(append)
    //OpenFile返回一个文件指针
    file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v\n", err)
        return
    }
    //关闭文件句柄
    defer file.Close()
    //读取原有内容，打印输出
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n')
        //如果读取到结尾，结束循环
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Println("读取文件出错了：", err)
        }
        //显示读取到的文本
        fmt.Print(str)
    }
    //准备写入新内容
    newStr := "加班万岁\n"
    //使用带缓存的*Writer
    writer := bufio.NewWriter(file)
    writer.WriteString(newStr)
    writer.Flush()
}

1.5. File copy

package main

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

//拷贝文件  dst目的文件   src源文件
func CopyFile(dstFile string, srcFile string) (written int64, err error) {

    src, err := os.Open(srcFile)
    if err != nil {
        fmt.Println("打开文件出错", err)
    }
    defer src.Close()
    dst, err := os.OpenFile(dstFile, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Printf("打开文件%s出错,错误：%v\n", dstFile, err)
        return
    }
    defer dst.Close()
    return io.Copy(dst, src)
}

func main() {
    //
    _, err := CopyFile("/Users/yuchao/helloCopy.txt", "/Users/yuchao/hello.txt")
    if err == nil {
        fmt.Println("拷贝完成")
    } else {
        fmt.Println("拷贝出错了，错误：", err)
    }
}

1.6. Gets command line arguments

Linux command such as

ls -la

os.args string package is a slice, for storing all command line arguments.

package main

import (
    "fmt"
    "os"
)

func main() {

    fmt.Printf("命令行参数有%d个\n", len(os.Args))
    for i, v := range os.Args {
        fmt.Printf("参数%d  是 %v\n", i, v)
    }
}

After code is compiled, a mass participation running

go build main.go 

./main alex peiqi xiaofeng   //传入三个参数

1.7. Flag packet parsing command line parameters

package main

import (
    "flag"
    "fmt"
)

func main() {
    /*
        flag包可以解析如下命令
        ./main -u root  -p 123  -h 127.0.0.1  -port 3306

    */

    //定义用于接收命令行的参数值
    var user string
    var pwd string
    var host string
    var port int

    flag.StringVar(&user, "u", "", "用户名，默认为空")
    flag.StringVar(&pwd, "p", "", "密码默认为空")
    flag.StringVar(&host, "h", "localhost", "主机名，默认localhost")
    flag.IntVar(&port, "port", 3306, "端口号，默认3306")

    flag.Parse()
    fmt.Printf("user=%v pwd=%v host=%v port=%v\n", user, pwd, host, port)
}

Run flag packet parsing

yugoMBP:gobook yuchao$ go run main.go -u root -p 123 -h 127.0.0.1 -port 3306
user=root pwd=123 host=127.0.0.1 port=3306