传送门：文件操作

主函数

//读文件
func main() {
    fmt.Println("======文件打开--func Open========")
    filedemo.FileOpen()
    fmt.Println("======文件读取--func (*File) Read========")
    filedemo.FileRead()
    fmt.Println("======循环读取--for========")
    filedemo.CycleRead()
    fmt.Println("======循环读取--bufio.NewReader(file)========")
    filedemo.BufioRead()   //带缓冲
    fmt.Println("======读取--ioutil.ReadFile(filePath)========")
    filedemo.IoutilRead()  //不需要Open和Close
}
//写文件
func main() {
    fmt.Println("====写文件操作os.OpenFile()&bufio.NewWriter====")
    filedemo.BufioWrite()
    fmt.Println("====覆盖原文件os.O_TRUNC====")
    filedemo.HaveWrite()
    fmt.Println("====追加os.O_APPEND====")
    filedemo.AddWrite()
    fmt.Println("====读写 os.O_RDWR ====")
    filedemo.RdwrWrite()
    fmt.Println("====a文件导入到b文件ioutil.ReadFile()&ioutil.WriteFile()====")
    filedemo.ToLeadWrite()
    fmt.Println("====判断文件是否存在os.Stat(path) ====")
    filedemo.BoolExists("e:/newproject/test_log/demo16/xx.txt")
    fmt.Println("====拷贝 图片/视频  ====")
    srcFile := "e:/newproject/Adream.jpg"
    dstFile := "e:/newproject/AdreamCopy.jpg"
    _, err := filedemo.CopyFile2(dstFile,srcFile)
    if err == nil {
        fmt.Println("拷贝完成")
    } else {
        fmt.Printf("拷贝错误 err = %v\n", err)
    }
}

判断文件是否存在os.Stat(path)

package filedemo
import (    
    "os"
)
/*func Stat 
func Stat(name string) (fi FileInfo, err error)
Stat返回一个描述name指定的文件对象的FileInfo。
如果指定的文件对象是一个符号链接，返回的FileInfo描述该符号链接指向的文件的信息，
本函数会尝试跳转该链接。如果出错，返回的错误值为*PathError类型。
*/
//判断文件是否存在 true 存在  false不存在
func BoolExists(path string) (bool,error)  {
    _ , err := os.Stat(path)
    //如果返回的错误为nil，说明文件或文件夹存在
    if err == nil{    
        return true,nil
    }
    //如果返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
    if os.IsNotExist(err){
        return false,nil
    }
    //如果返回的错误为其他类型，则不确定是否存在
    return false,err
}

打开文件os.Open(filePath)

package filedemo
/*
func Open
func Open(name string) (file *File, err error)
Open打开一个文件用于读取。
如果操作成功，返回的文件对象的方法可用于读取数据；
对应的文件描述符具有O_RDONLY模式。
如果出错，错误底层类型是*PathError。
*/
import (
    "fmt"
    "os"
)
//打开&关闭
func FileOpen() {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    fmt.Printf("%v\n", file)
    defer file.Close() //及时关闭，否则会发生内存泄露
}

读文件

文件读取file.Read(tmp)

package filedemo
/*
        func (*File) Read
        func (f *File) Read(b []byte) (n int, err error)
        Read方法从f中读取最多len(b)字节数据并写入b。
        它返回读取的字节数和可能遇到的任何错误。
        文件终止标志是读取0个字节且返回值err为io.EOF。
    */
import (
    "fmt"
    "io"
    "os"
)
//读取文件--基本读取
func FileRead() {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    defer file.Close()
    // 使用Read方法读取数据
    var tmp = make([]byte, 128)
    n, err := file.Read(tmp)
    if err == io.EOF {
        fmt.Println("文件读完了")
        return
    }
    if err != nil {
        fmt.Println("read file failed, err:", err)
        return
    }
    fmt.Printf("读取了%d字节数据\n", n)
    fmt.Println(string(tmp[:n]))
}

循环读取CycleRead-for语句

package filedemo
import (
    "fmt"
    "io"
    "os"
)
//读取文件--循环读取
func CycleRead() {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    defer file.Close()
    // 循环读取文件内容
    var content []byte
    var tmp = make([]byte, 128)
    for {
        n, err := file.Read(tmp)
        if err == io.EOF {
            fmt.Println("文件读完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        content = append(content, tmp[:n]...)
    }
    fmt.Println(string(content))
}

循环读取bufio.NewReader(file)

package filedemo
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
//bufio是在file的基础上封装了一层API，支持更多的功能
func BufioRead() {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    //循环读取文件内容
    for {
        //读到一个换行就结束
        line, err := reader.ReadString('\n') //注意是字符
        // 代表文件末尾  err!= nil
        if err == io.EOF {
            if len(line) != 0 {
                fmt.Println(line)
            }
            fmt.Println("文件读完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        fmt.Print(line)
    }
}

读取ioutil.ReadFile(filePath)

不需要Open和close

package filedemo
/*
func ReadFile
func ReadFile(filename string) ([]byte, error)
ReadFile 从filename指定的文件中读取数据并返回文件的内容。
成功的调用返回的err为nil而非EOF。
因为本函数定义为读取整个文件，它不会将读取返回的EOF视为应报告的错误。
*/
import (
    "fmt"
    "io/ioutil"
)
var filePath string = "e:/newproject/test_log/demo16/xx.txt"
//io/ioutil包的ReadFile方法能够读取完整的文件，只需要将文件名作为参数传入,只适合小文件
func IoutilRead() {
    content, err := ioutil.ReadFile(filePath)
    if err != nil {
        fmt.Println("read file failed, err:", err)
        return
    }
    // fmt.Printf("%v", content)    //[]byte  读出来都是数字
    fmt.Println(string(content)) //转换成string
    //没有显式的open文件，也不需要Close文件，都被封装到ReadFile内部了
}

写文件

创建并写入新文件

os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0666) + bufio.NewWriter(file)
创建一个新文件，写入5句你好，张三

package filedemo
//创建一个新文件，写入5句你好，张三
//func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
//写入时，使用带缓存的writer
//func NewWriter(w io.Writer) *Writer
//NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
import (
    "bufio"
    "fmt"
    "os"
)
//文件写入操作  --writeSetting带缓存
//os.OpenFile()函数能够以指定模式打开文件，从而实现文件写入相关功能。
func BufioWrite() {
    filePath := "e:/newproject/test_log/demo16/b.txt"
    file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    //及时关闭，防止泄露
    defer file.Close()
    //写入5句这个
    str := "hello，张三\n"
    //写入时，使用带缓存的writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //因为writer带缓存，因此在调用WriteString是先写入缓存的，
    //因此需要调用Flush方法，将缓存数据写道文件中，否则文件没有数据
    writer.Flush()
}

覆盖原文件

os.OpenFile(filePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666) + bufio.NewWriter(file)

package filedemo
//打开一个存在的文件，将原来的内容覆盖成新的10句再见张三
/*
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  // 如果可能，打开时清空文件
)
*/
import (
    "bufio"
    "fmt"
    "os"
)
/*
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
*/
//文件写入操作
//os.OpenFile()函数能够以指定模式打开文件，从而实现文件写入相关功能。
//writeSetting带缓存
func HaveWrite() {
    var filePath string = "e:/newproject/test_log/demo16/a.txt"
    file, err := os.OpenFile(filePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    //及时关闭，防止泄露
    defer file.Close()
    //写入5句这个
    str := "再见，张三\n"
    //写入时，使用带缓存的writer
    /*func NewWriter
    func NewWriter(w io.Writer) *Writer
    NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
    */
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString(str)
    }
    //因为writer带缓存，因此在调用WriteString是先写入缓存的，
    //因此需要调用Flush方法，将缓存数据写道文件中，否则文件没有数据
    writer.Flush()
}

追加

os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) + bufio.NewWriter(file)

package filedemo
/*func NewWriter
    func NewWriter(w io.Writer) *Writer
    NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
    */
import (
    "bufio"
    "fmt"
    "os"
)
//os.O_APPEND 追加
func AddWrite() {
    filePath := "e:/newproject/test_log/demo16/a.txt"
    file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    //及时关闭，防止泄露
    defer file.Close()
    //写入5句这个
    str := "法外狂徒\n"
    //写入时，使用带缓存的writer    
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //因为writer带缓存，因此在调用WriteString是先写入缓存的，
    //因此需要调用Flush方法，将缓存数据写道文件中，否则文件没有数据
    writer.Flush()
}

读写

os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0666)
bufio.NewReader(file)
bufio.NewWriter(file)

package filedemo
/*func NewWriter
    func NewWriter(w io.Writer) *Writer
    NewWriter创建一个具有默认大小缓冲、写入w的*Writer。
    */
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
func RdwrWrite() {
    filePath := "e:/newproject/test_log/demo16/a.txt"
    file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    //及时关闭，防止泄露
    defer file.Close()
    //先读取原来的内容，并显示在终端
    reader := bufio.NewReader(file)
    for {
        str,err := reader.ReadString('\n')
        if err == io.EOF{
            break
        }
        //显示到终端
        fmt.Println(str)
    }
    //写入5句这个
    str := "哪里跑\n"
    //写入时，使用带缓存的writer    
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //因为writer带缓存，因此在调用WriteString是先写入缓存的，
    //因此需要调用Flush方法，将缓存数据写道文件中，否则文件没有数据
    writer.Flush()
}

a文件导入到b文件

ioutil.ReadFile(filepath1)
ioutil.WriteFile(filepath2,data,0666)

package filedemo
import (
    "fmt"
    "io/ioutil"
)
func ToLeadWrite()  {
    //将aa.txt导入到bb.txt
    //1. 将aa.txt内容读取到内存
    //2. 将读取到的内容写入 bb.txt
    filepath1 := "E:/newproject/test_log/demo16/a.txt"
    filepath2 := "E:/newproject/test_log/demo16/bb.txt"
    data , err := ioutil.ReadFile(filepath1)
    if(err != nil){
        //说明文件读取有错误
        fmt.Printf("read file err = %v",err)
        return
    }
    err = ioutil.WriteFile(filepath2,data,0666)
    if err != nil{
        fmt.Printf("write file err = %v", err)
    }
}

拷贝图片/视频

os.Open(srcFileName)
os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0644)

package filedemo
import (
    "fmt"
    "io"
    "os"
)
/*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)进行拷贝。
*/
//将一个文件 图片/电影 拷贝到另一个文件下
//自己写一个函数，接受两个文件路径  srcFileName  dstFileName
func CopyFile2(dstFileName, srcFileName string) (written int64, err error) {
    // 以读方式打开源文件
    src, err := os.Open(srcFileName)
    if err != nil {
        fmt.Printf("open %s failed, err:%v.\n", srcFileName, err)
        return
    }
    defer src.Close()
    // 以写|创建的方式打开目标文件
    dst, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Printf("open %s failed, err:%v.\n", dstFileName, err)
        return
    }
    defer dst.Close()
    return io.Copy(dst, src) //调用io.Copy()拷贝内容
}