GO基础之文件操作

一、文件操作的基本api

func main() {
    //绝对路径
    fileinfo , err := os.stat("e:/a.txt")
    fileinfo , err = os.stat("e:/")
    if err !=nil {
        fmt.println("err:" , err.error())
    } else {
        fmt.printf("%t \n" , fileinfo)
        fmt.printf("%v \n" , fileinfo)
        //文件名
        fmt.println(fileinfo.name())
        //是否是目录
        fmt.println(fileinfo.isdir())
        //文件尺寸大小
        fmt.println(fileinfo.size())
        //mode 权限
        fmt.println(fileinfo.mode())
        //文件最后修改时间
        fmt.println(fileinfo.modtime())
    }
}

文件路径：

• 1、绝对路径：absolute
• 2、相对路径：relative 都是相当于当前的工程  (.当前目录   ..上一层)

（1）、判断是否是绝对路径filepath.isabs()
（2）、获取相对路径filepath.rel()
（3）、获取绝对路径filepath.abs()
（4）、拼接路径path.join(）

文件操作：
1.创建文件夹,如果文件夹存在，创建失败

• os.mkdir()
• os.mkdirall()

2.创建文件：如果文件存在，会覆盖

• os.create()-->*file

3.打开文件：

• os.open(filename)
• os.openfile(filename,mode,perm)

4.关闭文件：

• file.close()

5.删除：

• os.remove()
• os.removeall()

package main

import (
    "os"
    "fmt"
)

func main() {
    /*
    文件操作：
        1.创建文件夹,如果文件夹存在，创建失败
            os.mkdir()
            os.mkdirall()

        2.创建文件：如果文件存在，会覆盖
            os.create()-->*file

        3.打开文件：
            os.open(filename)
            os.openfile(filename,mode,perm)
        4.关闭文件：
            file.close()
        5.删除：
            os.remove()
            os.removeall()
     */
    //     1、创建目录
    filename1 := "./test1"
    err := os.mkdir(filename1, os.modeperm)
    if err != nil {
        fmt.println("err:", err.error())
    } else {
        fmt.printf("%s 目录创建成功！\n", filename1)
    }

    filename2 := "./test2/abc/xyz"
    err = os.mkdirall(filename2, os.modeperm)
    if err != nil {
        fmt.println("err:", err.error())
    } else {
        fmt.printf("%s 目录创建成功！\n", filename2)
    }

    //2、创建文件.如果文件已经存在，则文件被覆盖
    filename3 := "./test1/abc.txt"
    file1, err := os.create(filename3)
    if err != nil {
        fmt.println("err:", err.error())
    } else {
        fmt.printf("%s 创建成功！%v \n", filename3, file1)
    }

    //    3、打开文件
    file2, err := os.open(filename3)
    if err != nil {
        fmt.println("err:", err.error())
    } else {
        fmt.printf("%s 打开成功！%v \n", filename3, file2)
    }

    /*
    第一个参数：文件名称
    第二个参数：文件的打开方式
        o_rdonly：只读模式(read-only)
        o_wronly：只写模式(write-only)
        o_rdwr：读写模式(read-write)
        o_append：追加模式(append)
        o_create：文件不存在就创建(create a new file if none exists.)
    第三个参数：文件的权限：文件不存在创建文件，需要指定权限
     */
    filename4 := "./test1/abc2.txt"
    file4, err := os.openfile(filename4, os.o_rdwr|os.o_create, os.modeperm)
    if err != nil {
        fmt.println("err:", err.error())
    } else {
        fmt.printf("%s 打开成功！%v \n", filename4, file4)
    }

    //4、关闭文件，程序与文件的联系断开
    file4.close()

    //    5、删除文件和目录
    filename5 := "./test1"
    err = os.remove(filename5)
    if err != nil {
        fmt.println(err)
    } else {
        fmt.printf("%s 删除成功！" , filename5)
    }

    err = os.removeall(filename5)
    if err != nil {
        fmt.println(err)
    } else {
        fmt.printf("%s 删除成功！" , filename5)
    }
}

文件读写 

/**
2.读取文件file.read([]byte)-->n,err 从文件中开始读取数据，存入到byte切片中，返回值n是本次实际读取的数据量如果读取到文件末尾，n为0,err为eof：end of file
 */
func readfile(filename string){
    file2,err:=os.openfile(filename, os.o_rdwr|os.o_create, os.modeperm)
    if err!=nil{
        fmt.println(file2);
    }else {
        bs:=make([]byte,8,1024*8);
        n:= -1;
        str:="";
        for{
            n,err=file2.read(bs);
            fmt.printf("n:%v \n",n)
            if n==0||err==io.eof{
                fmt.println("read file end")
                break;
            }
            str= strings.join([]string{str,string(bs[:n])},"")
        }
        fmt.println(str)
    }
    //3、关闭文件
    file2.close()
}
func writefile(filename string){
    str:="i love china 我爱中国";
    bs:=[]byte(str);
    file2,err:=os.openfile(filename, os.o_rdwr|os.o_create, os.modeperm)
    if err!=nil{
        fmt.println(file2);
    }else {
        file2.write(bs);
    }
    file2.close();
}

二、ioutil 包

/*
ioutil包：
readfile() //读取文件中的所有的数据，返回读取的字节数组
writefile() //向指定文件写入数据，如果文件不存在，则创建文件，写入数据之前清空文件
readdir() //读取一个目录下的子内容：子文件和子目录，但是仅有一层
tempdir(） //在当前目录下，创建一个以指定字符串为前缀的临时文件夹，并返回文件夹路径
tempfile() //在当前目录下，创建一个以指定字符串为前缀的文件，并以读写模式打开文件，并返回os.file指针对象
*/

package main

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

func main() {
    /*
    ioutil包：
        readfile()   //读取文件中的所有的数据，返回读取的字节数组
        writefile()  //向指定文件写入数据，如果文件不存在，则创建文件，写入数据之前清空文件
        readdir()    //读取一个目录下的子内容：子文件和子目录，但是仅有一层
        tempdir(）   //在当前目录下，创建一个以指定字符串为前缀的临时文件夹，并返回文件夹路径
        tempfile()   //在当前目录下，创建一个以指定字符串为前缀的文件，并以读写模式打开文件，并返回os.file指针对象
     */
    //1、readfile()   //读取文件中的所有的数据，返回读取的字节数组
    filename1 := "./files/blockchain.txt"
    data, err := ioutil.readfile(filename1)
    if err != nil {
        fmt.println("文件打开异常", err.error())
    } else {
        fmt.println(string(data))
    }

    //2、writefile()  //向指定文件写入数据，如果文件不存在，则创建文件，写入数据之前清空文件
    filename2 := "./files/xyz.txt"
    s1 := "steven陪你学区块链"
    err = ioutil.writefile(filename2, []byte(s1), 0777)
    if err != nil {
        fmt.println("写入文件异常", err.error())
    } else {
        fmt.println("文件写入ok!")
    }

    //3、文件拷贝
    err = ioutil.writefile(filename2 , data , os.modeperm)
    if err != nil {
        fmt.println("文件拷贝异常", err.error())
    } else {
        fmt.println("文件拷贝成功!")
    }

    //4、readdir()    //读取一个目录下的子内容：子文件和子目录，但是仅有一层
    dirname := "./"
    fileinfos , err := ioutil.readdir(dirname)
    if err != nil {
        fmt.println("目录遍历异常", err.error())
    } else {
        for i , v := range fileinfos {
            fmt.println(i , v.name() , v.isdir() , v.size() , v.modtime())
        }
    }

    //5、tempdir(）   //在当前目录下，创建一个以指定字符串为前缀的临时文件夹，并返回文件夹路径
    filename , err := ioutil.tempdir("./" , "temp")
    if err != nil {
        fmt.println("创建目录失败" , err.error())
    } else {
        fmt.println(filename)
    }

    //6、tempfile()   //在当前目录下，创建一个以指定字符串为前缀的文件，并以读写模式打开文件，并返回os.file指针对象
    file1 , err := ioutil.tempfile(filename , "temp")
    if err != nil {
        fmt.println("创建文件失败" , err.error())
    } else {
        file1.writestring("写入内容:" + file1.name())
    }
    file1.close()
}