go语言io和ioutil包的学习和使用

io包

package main;

import (
        "errors"
        "fmt"
        "io"
)

//io包中定义了非常多的interface
//只要实现了接口中的方法
//那么io包中的导出方法就可以传入我们自定义的对象然后进行处理
//像什么文件数据，网络数据，数据库数据都可以统一操作接口

type MyReWr struct {
        //保存的数据
        data string;
        //指向当前数据读取的位置下标
        rix int;
        //指向当前数据写入的位置下标
        wix int;
}

func MyReWrNew(s string) *MyReWr {
        return &MyReWr{s, 0, 0};
}

//读取数据到p中
func (m *MyReWr) Read(p []byte) (n int, err error) {
        l := len(p);
        num := 0;
        if m.rix >= len(m.data) {
                return 0, errors.New("EOF");
        }
        tmp := []byte(m.data);
        //判断当前数据读取的下标
        if (m.rix + l) < len(m.data) {
                num = l;
        } else {
                num = len(m.data) - m.rix;
        }
        //循环给p设置数据
        for ix := 0; ix < num; ix++ {
                p[ix] = tmp[m.rix+ix];
        }
        //增加读取下标
        m.rix = m.rix + num;
        return num, nil;
}

//将p中数据写入
func (m *MyReWr) Write(p []byte) (n int, err error) {
        l := len(p);
        num := 0;
        if m.wix >= len(m.data) {
                return 0, errors.New("EOF");
        }
        tmp := []byte(m.data);
        //判断当前数据写入的下标
        if (m.wix + l) < len(m.data) {
                num = l;
        } else {
                num = len(m.data) - m.wix;
        }
        //循环写入数据
        for ix := 0; ix < num; ix++ {
                tmp[m.wix+ix] = p[ix];
        }
        m.data = string(tmp);
        //增加写入下标
        m.wix = m.wix + num;
        return num, nil;
}

func main() {
        //我们自定义的一个结构，实现了Read和Write方法
        m := MyReWrNew("12345678910");
        p := make([]byte, 3);
        //循环读取数据
        for {
                n, _ := m.Read(p);
                if n == 0 {
                        break;
                }
                fmt.Println(n, string(p[0:n]));
        }
        //循环写入数据
        for {
                n, _ := m.Write([]byte("111"));
                if n == 0 {
                        break;
                }
                fmt.Println(n, m.data);
        }

        //MyReWr结构就可以使用如下方法
        m2 := MyReWrNew("666666666");
        m3 := MyReWrNew("999999999");
        tee := io.TeeReader(m2, m3);
        for {
                //循环从m2中读取数据到p中，再写入到m3中。
                n, _ := tee.Read(p);
                if n == 0 {
                        break;
                }
                fmt.Println(m2, m3);
        }

        //向m4中拷贝m5中的数据
        m4 := MyReWrNew("aaaaaaaaa");
        m5 := MyReWrNew("mmmmmmm");
        io.Copy(m4, m5);
        fmt.Println(m4, m5);

        //从m6中读取数据放入p2中
        m6 := MyReWrNew("abcdefghijklmo");
        p2 := make([]byte, len(m6.data));
        io.ReadFull(m6, p2);
        fmt.Println(string(p2));

        //向m7中写入字符串，如果实现了WriteString方法会直接调用。
        m7 := MyReWrNew("hello");
        io.WriteString(m7, "world123");
        fmt.Println(m7);
}

ioutil包

package main;

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

func main() {
        //NopCloser返回一个读取对象的ReadCloser接口
        //用于提供Close方法
        r := strings.NewReader("hello");
        rcl := ioutil.NopCloser(r);
        defer rcl.Close();

        //ReadAll读取所有数据
        r2 := strings.NewReader("1234567890");
        p, _ := ioutil.ReadAll(r2);
        fmt.Println(string(p));

        //读取目录下信息
        fileInfo, _ := ioutil.ReadDir("./");
        for _, v := range fileInfo {
                fmt.Println(v.Name());
        }

        //读取整个文件数据
        data, _ := ioutil.ReadFile("./1.txt");
        fmt.Println(string(data));

        //向指定文件写入数据，如果文件不存在，则创建文件，写入数据之前清空文件
        ioutil.WriteFile("./xxx.txt", []byte("hello,world"), 0655);

        //在当前目录下，创建一个以test为前缀的临时文件夹，并返回文件夹路径
        name, _ := ioutil.TempDir("./", "test");
        fmt.Println(name);

        //在当前目录下，创建一个以test为前缀的文件，并以读写模式打开文件，并返回os.File指针
        file, _ := ioutil.TempFile("./", "test");
        file.WriteString("写入字符串");
        file.Close();
}