30 Golang文件、目录操作

一、读取文件

• 方法一（file.Read()）

1. 只读方式打开文件

2. 读取文件file.Read()

3. 关闭文件流 defer file.Close()

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

func main() {
    //打开文件
    file, err := os.Open("./main.go")
    defer file.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
    //读取文件，每次读取128个
    var strSlice []byte
    var tempSlice = make([]byte, 128)
    for {
        n, err := file.Read(tempSlice)
        if err == io.EOF {  //err等于io.EOF表示读取完毕
            fmt.Println("读取完毕")
            break
        }
        if err != nil {
            fmt.Println("读取失败")
            return
        }
        strSlice = append(strSlice, tempSlice[:n]...)
    }
    fmt.Println(string(strSlice))
}

• 方法二（bufio）

1. 只读方式打开文件file, err := os.Open()

2. 创建reader对象 reader := bufio.NewReader(file)

3. ReadString读取文件 line, err := reader.ReadString('\n')

4. 关闭文件流 defer file.close()

func main(){
    file, err := os.Open("./main.go")
    defer file.Close()

    if err != nil {
        fmt.Println(err)
        return
    }

    //bufio读取文件
    var fileStr string
    reader := bufio.NewReader(file)
    for {
        //每次读取一行
        str, err := reader.ReadString('\n')
        if err == io.EOF {
            fileStr += str
            break
        }
        if err != nil {
            fmt.Println(err)
            return
        }
        fileStr += str
    }
    fmt.Println(fileStr)
}

• 方法三（ioutil）

打开关闭文件的方法都封装好了，如果文件比较小，只需要一句话就可以读取，不需要判断何时读取完毕、何时关闭等。

import (
    "fmt"
    "io/ioutil"
)

func main() {
    byteStr, err := ioutil.ReadFile("C:/test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(byteStr))
}

二、写文件

• 方法一

1. OpenFile打开文件
2. 写入文件file.Write([]byte(str))
3. 关闭文件流

其中, OpenFile有两个参数(打开文件的名称，打开文件的模式)

模式	含义
os.O_WRONLY	只写
os.O_CREATE	创建文件
os.O_RDONLY	只读
os.O_RDWR	读写
os.O_TRUNC	清空
os.O_APPEND	追加

perm :文件权限 r(可读)4 w(可写)2 x(可执行)1

func OpenFile(name string, perm FileMode)(*File, error){
    ……
}

• demo

func main() {
    file, err := os.OpenFile("D:/test.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    defer file.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
    for i := 0; i < 10; i++ {
        file.WriteString("第" + strconv.Itoa(i) + "行：直接写入的字符串数据\n")
    }
}

//第0行：直接写入的字符串数据
//第1行：直接写入的字符串数据
//第2行：直接写入的字符串数据
//第3行：直接写入的字符串数据
//第4行：直接写入的字符串数据
//第5行：直接写入的字符串数据
//第6行：直接写入的字符串数据
//第7行：直接写入的字符串数据
//第8行：直接写入的字符串数据
//第9行：直接写入的字符串数据

• 方法二（bufio）

1. 打开文件
2. 创建writer对象
3. 将数据先写入缓存
4. 将缓存中的内容写入文件
5. 关闭文件流file.Close()

func main() {
    file, err := os.OpenFile("D:/test.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    defer file.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
    writer := bufio.NewWriter(file)
    //将数据写入缓存
    writer.WriteString("你好golang")
    //将缓存中的内容写入文件
    writer.Flush()
}

• 方法三（ioutil）

func main() {
    str := "你好golang"
    err := ioutil.WriteFile("D:test.txt", []byte(str), 0666)
    if err != nil {
        fmt.Println("write file failed, err", err)
        return
    }
}

三、复制文件

• 方法一

//(源文件名,目标文件名)
func copy(srcFileName string, dstFileName string) (err error) {
    byteStr, err1 := ioutil.ReadFile(srcFileName)
    if err1 != nil {
        return err1
    }
    err2 := ioutil.WriteFile(dstFileName, byteStr, 006)
    if err2 != nil {
        return err2
    }
    return nil
}
func main() {
    src := "D:/test.txt"
    dst := "D:/new-test.txt"
    err := copy(src, dst)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("复制文件成功")
    }
}

• 方法二

以文件流的方式复制文件

func copy(srcFileName string, dstFileName string) (err error) {
    sFile, err1 := os.Open(srcFileName)
    //关闭文件流，防止内存泄露
    defer sFile.Close()
    dFile, err2 := os.OpenFile(dstFileName, os.O_CREATE|os.O_WRONLY, 0666)
    defer dFile.Close()
    if err1 != nil {
        return err1
    }
    if err2 != nil {
        return err2
    }
    var tempSlice = make([]byte, 128)
    sFile.Read(tempSlice)
    for {
        //边读边写
        //读取
        n1, err := sFile.Read(tempSlice)
        //如果读取完毕，跳出for循环
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
        //写入
        if _, err := dFile.Write(tempSlice[:n1]); err != nil {
            return err
        }
    }
    return nil
}
func main() {
    src := "D:/test.txt"
    dst := "D:/new-test.txt"
    err := copy(src, dst)
    if err == nil {
        fmt.Println("复制文件成功")
    } else {
        fmt.Println(err)
    }
}

四、创建目录

在当前目录下，创建lxc文件夹

func main() {
    err := os.Mkdir('./lxc', 0666)
    if err != nil {
        fmt.Println(err)
    }
}

上面的这种情况，在当前目录已经存在该文件夹时会报错，而我们通常想，目录存在时不做任何操作，即：

os.Mkdir('./lxc', 0666)

也可以一次生成多层目录

err := os.MkdirAll("./dir1/dir2/dir3", 0666)

五、删除目录或文件

• Remove

删除文件

err := os.Remove("lxc.txt")
if err != nil {
    fmt.Println(err)
}

删除目录

err := os.Remove("./lxc")
if err != nil {
    fmt.Println(err)
}

• RemoveAll一次删除多个文件

err := os.RemoveAll("dir")
if err != nil {
    fmt.Println(err)
}

Remove操作文件或目录不存在时会报错，而RemoveAll不会

六、文件重命名

//只能同盘操作
err := os.Rename("D:/test.txt", "D:/test1.txt")