Go语言之文件操作

一、文件基本介绍

文件就是保存数据用的，它可以保存一段文字、一张图片，也可以是声音或者视频等，它在程序中以流的形式来操作。

os包下的File结构体含了所有的文件相关操作：

type File

type File struct {
    // 内含隐藏或非导出字段
}

File代表一个打开的文件对象。

func Open

func Open(name string) (file *File, err error)

Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。

func (*File) Close

func (f *File) Close() error

Close关闭文件f，使文件不能用于读写。它返回可能出现的错误。

...

更多查看：https://studygolang.com/static/pkgdoc/pkg/os.htm#File

二、打开文件及关闭文件

对文件的操作首先就是打开，其次是操作文件，最后是关闭文件。所以打开和关闭文件必不可少。

打开和关闭就使用上面提到的

案例演示：

package main

import (
    "fmt"
    "os"
)

func main() {
    // 打开该目录下的1.txt文件
    file, err := os.Open("./1.txt")
    if err != nil {
        fmt.Println("文件打开出错...")
    }
    // 输出文件，它是一个指针
    fmt.Println(file) // &{0xc00007c780}

    // 关闭文件
    err = file.Close()
    if err != nil {
        fmt.Println("文件关闭出错...")
    }

}

三、文件读操作

带缓冲区读操作
一次性读操作

1、带缓冲区读操作

带缓冲区读操作，就是讲文件一部分、一部分的进行读取到内存中，适用于大文件，涉及到的函数和方法有：

os.Open
file.Close
bufio.NewReader
reader.ReadString

package main

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

func main() {

    // 打开一个文件
    file, err := os.Open("./1.txt")
    if err != nil {
        fmt.Println("文件打开出错...")
    }

    // 延时关闭文件, 函数执行完毕自动关闭文件
    defer file.Close()

    // 文件读操作
    // 返回的是一个*Reader类型的缓冲区, 默认的缓存大小4096
    reader := bufio.NewReader(file)
    // 循环读取文件内容
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF {
            // io.EOF表示文件末尾，就结束读取
            break
        }
        // 输出每一行内容
        fmt.Println(str)
    }

}

2、一次性读操作

一次性读操作适用于小文件，涉及的函数和方法有：

ioutil.ReadFile

这个函数实践文件的打开和关闭封装在内部，所以无需显式的操作。

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    // 打开一个文件
    content, err := ioutil.ReadFile("./1.txt")
    if err != nil {
        fmt.Println("文件打开出错...")
    }

    // 文件读操作
    // content是一个字节切片类型
    fmt.Println(string(content))

}

四、文件写操作

（一）os.OpenFile

func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。

参数说明：

name 表示的是文件的路径字符串
flag 文件打开模式
perm 权限控制，用于Linux中的权限（r-->4、w-->2、x-->1）

flag可选值：

const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)

（二）案例演示

文件写操作也有两种方式：

带缓存的写入
一次性写入

这与读文件是一样的，不过上述两种方式对文件操作又有各种不同模式的组合。

1、带缓存的写入

创建文件并写入内容

package main

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

func main() {

    filePath := "./2.txt"
    // 只写模式打开文件、如果文件不存在就创建
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Println("文件错误...")
        return
    }
    // 函数执行完毕关闭文件
    defer file.Close()

    // 向文件写入内容
    str := "hello world!"

    // 使用带缓存的写入
    writer := bufio.NewWriter(file)
    writer.WriteString(str)

    // writer带缓存的，所以在调用WriterString方法时，其实
    // 时先写入到缓存中，所以需要调用Flush方法，将缓存中的数据
    // 真正写入到文件，否则文件中没有数据
    writer.Flush()

}

覆盖已经存在的内容

package main

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

func main() {

    filePath := "./2.txt"
    // 覆盖已经存在文件中的内容
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0666)
    if err != nil {
        fmt.Println("文件错误...")
        return
    }
    // 函数执行完毕关闭文件
    defer file.Close()

    // 向文件写入内容
    str := "hello iveboy"

    // 使用带缓存的写入
    writer := bufio.NewWriter(file)
    writer.WriteString(str)

    // writer带缓存的，所以在调用WriterString方法时，其实
    // 时先写入到缓存中，所以需要调用Flush方法，将缓存中的数据
    // 真正写入到文件，否则文件中没有数据
    writer.Flush()

}

读文件于追加内容

package main

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

func main() {

    filePath := "./2.txt"
    // 覆盖已经存在文件中的内容
    file, err := os.OpenFile(filePath, os.O_RDONLY|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("文件错误...")
        return
    }
    // 函数执行完毕关闭文件
    defer file.Close()

    // 读文件
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF {
            fmt.Println("已经读到文件末尾了...")
            break
        }
        fmt.Print(str)
    }

    // 向文件中写内容
    str := "hello iveboy"

    // 使用带缓存的写入
    writer := bufio.NewWriter(file)
    writer.WriteString(str)

    // writer带缓存的，所以在调用WriterString方法时，其实
    // 时先写入到缓存中，所以需要调用Flush方法，将缓存中的数据
    // 真正写入到文件，否则文件中没有数据
    writer.Flush()

}

2、一次性写入

将一个文件的内容写入到另一个文件中：

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    // 1、将已经存在的文件a.txt中的内容读取到内存
    // 2、将内存中的内容写入到文件b.txt

    filePath1 := "./a.txt"
    filePath2 := "./b.txt"

    // 读取a.txt文件中的内容
    data, err := ioutil.ReadFile(filePath1)
    if err != nil {
        fmt.Println("文件读取错误...")
        return
    }

    // 打开写入的文件，如果文件不存在就会创建，然后写入数据
    err = ioutil.WriteFile(filePath2, data, 0666)
    if err != nil {
        fmt.Println("打开写入的文件错误...")
    }

}

五、文件其它操作

1、判断文件是否存在

golang通过对os.Stat()函数返回的错误值进行判断：

如果返回的错误为nil，则文件或者文件夹存在
如果通过os.IsNotExist()判断为true，说明文件或文件夹不存在
如果返回的错误类型为其它类型，则不确定是否存在

package mian

import "os"

func PathIfExists(path string) (bool, error) {
    _, err := os.Stat(path)
    if err == nil {
        // 文件或目录存在
        return true, nil
    }
    if os.IsNotExist(err) {
        // 文件或目录不存在
        return false, nil
    }

    return false, err
}

2、文件拷贝

将文本、图片、音频、视频等文件从一个位置拷贝到另一个位置，比如：将 d:/1.jpg拷贝到e:/1.jpg

其本质就是使用io包下的copy方法：

func Copy

func Copy(dst Writer, src Reader) (written int64, err error)

将src的数据拷贝到dst，直到在src上到达EOF或发生错误。返回拷贝的字节数和遇到的第一个错误。

对成功的调用，返回值err为nil而非EOF，因为Copy定义为从src读取直到EOF，它不会将读取到EOF视为应报告的错误。如果src实现了WriterTo接口，本函数会调用src.WriteTo(dst)进行拷贝；否则如果dst实现了ReaderFrom接口，本函数会调用dst.ReadFrom(src)进行拷贝。

package main

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

// 接收两个路径参数
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
    // 打开源文件
    srcFile, err := os.Open(srcFileName)
    if err != nil {
        fmt.Printf("open srcFile err %v", err)
        return
    }
    // 延时关闭文件
    defer srcFile.Close()
    // 创建一个读文件的缓冲区
    reader := bufio.NewReader(srcFile)

    // 打开目标地址
    dstFile, err := os.OpenFile(dstFileName, os.O_CREATE|os.O_WRONLY, 0666)

    if err != nil {
        fmt.Printf("open dstFile err %v", err)
        return
    }
    // 创建一个写文件的缓冲区
    writer := bufio.NewWriter(dstFile)
    // 延时关闭文件
    defer dstFile.Close()

    return io.Copy(writer, reader)

}

func main() {
    srcFileName := "d:/1.jpg"
    dstFileName := "e:/1.jpg"
    _, err := CopyFile(dstFileName, srcFileName)
    if err == nil {
        fmt.Println("拷贝完成")
    } else {
        fmt.Printf("拷贝错误 %v", err)
    }
}

作者：iveBoy

出处：http://www.cnblogs.com/shenjianping/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须在文章页面给出原文连接，否则保留追究法律责任的权利。

Go语言之文件操作

一、文件基本介绍

二、打开文件及关闭文件

三、文件读操作

1、带缓冲区读操作

2、一次性读操作

四、文件写操作

（一）os.OpenFile

（二）案例演示

1、带缓存的写入

2、一次性写入

五、文件其它操作

1、判断文件是否存在

2、文件拷贝

继续阅读

Go语言结构体、方法、接口1.结构体2 方法3 接口

Golang学习——结构体struct(二)一.匿名结构体和匿名字段二.结构体嵌套三.结构体模拟继承性

golang 学习（二十四）结构体struct 和 json之间的转换结构体struct 和 json之间的转换

golang中结构体与jsongolang中结构体与json

golang结构体tag编译错误的问题

Golang结构体中的tag

GO语言笔记--结构体1.说明2.工厂函数

Go语言之map与结构体初入map结构体初入（场景map的value通常为struct）

Go初探 (5) – 结构体与接口

go(7)结构体，方法，接口

Go学习笔记: 结构体、方法、接口

06结构体、接口结构体接口

go语言笔记（结构体、方法、接口）go语言笔记（结构体、方法、接口）

Go中结构体和接口的定义

Rich Domain Model

Linux之父警告全球程序员：我刚发布的5.12内核有bug，你们千万别用