Golang 文件操作

★基本介绍

　　1）打开一个文件进行操作：

　　　　os.Open(name string) ( *File,error)

　　2）关闭一个文件

　　　　File.Close()

★读文件

1）带缓冲区的读取方式

读取文件的内容并显示在终端（带缓冲区的方式），使用os.Open，file.Close，bufio.NewReader()，reader.ReadString 函数和方法

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)
func main(){
    file ,err :=os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=",err)
    }
    //当函数退出时，要及时的关闭file
    //否则会有内存泄漏
    defer file.Close()
    reader := bufio.NewReader(file)
    //循环的读取文件内容
    for{
        str, err := reader.ReadString('\n')
        if err == io.EOF{//io.EOF 表示文件的末尾
            break
        }
        //输出内容
        fmt.Printf(str)
    }

}

 2）一次性读取文件

适用于小文件

package main
import (
    "fmt"
    "io/ioutil"
)

func main(){
    //使用ioutil.ReadFile 一次性将文件读取到位
    file := "d:/test.txt"
    content,err := ioutil.ReadFile(file)
    if err != nil {
        fmt.Printf("read file err =%v",err)
    }
    fmt.Printf("%v",string(content))
}

 ★写文件

　　基本介绍

func OpenFile(name string,flag int,per FileModel) (file *File,err error)

　　说明：os.OpenFile 是一个更一般性的文件打开函数，他会使用指定的选项、指定的模式打开i指定名称的文件，如果操作成功，返回的文件对象可用于I/O，如果出错，错误底层类型是 *PathError

　　第二个参数：文件打开模式（可以组合用）：

    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_CREATE//如果不存在则创建一个新文件
        O_EXCL int = sysycall.O_EXCL//和O_CREATE 配合使用，文件必须不存在
        O_SYNC int = syscall.O_SYNC//打开文件用于同步I/O
        O_TRUNC int = syscall.O_TRUNC//如果可能，打开时清空文件
    }

　　第三个参数：权限控制（Linux）

案例一：创建一个新文件，写入内容5 句“hello,Gardon”

package main

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

func main(){
    //创建一个新文件，写入内容 5句 “hello，Gardon”
    //1.打开文件 d:/abc.txt
    filePath :="d:/abc.txt"
    file, err := os.OpenFile(filePath,os.O_WRONLY | os.O_CREATE,0666)
    if err != nil {
        fmt.Printf("open file err=%v\n",err)
        return
    }
    //及时关闭file句柄
    defer file.Close()
    //准备写入5句 “hello，Gardon”
    str := "hello,Gardon\n"
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0;i < 5; i++{
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用writerSting方法时，其实
    //内容是先写入到缓存的，所以需要调用Flus方法，将缓冲的数据
    //真正写入到文件中，否则文件中会没有数据
    writer.Flush()
}

案例二：打开一个存在的文件，将原来的内容覆盖成新的内容 10句“你好，创客未来”

package main

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

func main() {
    //创建一个新文件，写入内容 5句 “hello，Gardon”
    //1.打开文件 d:/abc.txt
    filePath := "d:/test.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    //及时关闭file句柄
    defer file.Close()
    //准备写入10句 “你好，创客未来”
    str := "你好，创客未来\n"
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用writerSting方法时，其实
    //内容是先写入到缓存的，所以需要调用Flus方法，将缓冲的数据
    //真正写入到文件中，否则文件中会没有数据
    writer.Flush()
}

案例三：将文件A导入（复制）到文件B

package main

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

func main() {
    //将d:/test.txt 文件内容导入到 e:/kkk.txt
    //1. 首先将 d:/text.txt 内容读取到内存
    //2. 将读取到的内容写入 d:/kkk.txt
    file1Path := "d:/text.txt"
    file2Path := "d:/kkk.txt"
    data,err := ioutil.ReadFile(file1Path)
    if err != nil {
        //说明文件读取有错误
        fmt.Printf("read file err=v%\n",err)
        return
    } 
    err = ioutil.WriteFile(file2Path,data,0666)
    if err != nil {
        fmt.Printf("write file error=%v\n",err)
    }
}

★判断文件是否存在

golang判断文件或文件夹是否存在的方法为使用 os.Stat()函数返回的错误值进行判断：

1）如果返回的错误为null,说明文件或文件夹存在

2）如果返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在

3）如果返回的错误为其他类型，则不确定是否存在

func PathExists(path string)(bool,error){
    _,err := os.Stat(path)
    if err == nil {
        return true,nil
    }
    if os.IsNotExist(err){
        return false,nil
    }
    return false,err
}