Go语言学习笔记18.文件操作

系统函数

func Create(name string) (file *File, err Error)
根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666的文件，返回的文件对象是可读写的。

func NewFile(fd uintptr, name string) *File
根据文件描述符创建相应的文件，返回一个文件对象

func Open(name string) (file *File, err Error)
该方法打开一个名称为name的文件，但是是只读方式，内部实现其实调用了OpenFile。

func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限

func (file *File) Write(b []byte) (n int, err Error)
写入byte类型的信息到文件

func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
在指定位置开始写入byte类型的信息

func (file *File) WriteString(s string) (ret int, err Error)
写入string信息到文件

func (file *File) Read(b []byte) (n int, err Error)
读取数据到b中

func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
从off开始读取数据到b中

func Remove(name string) Error
调用该函数就可以删除文件名为name的文件

封装函数

package myLib2

import (
    "bufio"
    "fmt"
    "io"
    "os"
)
//打开文件
func CreateFile(path string) os.File {
    fout, err := os.Create(path)
    if err != nil {
        fmt.Println(err)
    }
    return *fout
}
//写字符
func WriteByte(f os.File,b []byte) {
    f.Write(b)
}
//写字符串
func WriteString(f os.File, input string) {
    f.WriteString(input)
}
//读文件所有内容
func ReadFile(path string) {
    //打开文件
    f, err := os.Open(path)
    if err != nil {
        fmt.Println("err = ", err)
        return
    }

    //关闭文件
    defer f.Close()

    buf := make([]byte, 1024*2) //2k大小

    //n代表从文件读取内容的长度
    n, err1 := f.Read(buf)
    if err1 != nil && err1 != io.EOF { //文件出错，同时没有到结尾
        fmt.Println("err1 = ", err1)
        return
    }
    fmt.Println("buf = ", string(buf[:n]))
}

//每次读取一行
func ReadFileLine(path string) {
    //打开文件
    f, err := os.Open(path)
    if err != nil {
        fmt.Println("err = ", err)
        return
    }

    //关闭文件
    defer f.Close()

    //新建一个缓冲区，把内容先放在缓冲区
    r := bufio.NewReader(f)

    for {
        //遇到'\n'结束读取, 但是'\n'也读取进入
        buf, err := r.ReadBytes('\n')
        if err != nil {
            if err == io.EOF { //文件已经结束
                break
            }
            fmt.Println("err = ", err)
        }

        fmt.Printf("buf = #%s#\n", string(buf))
    }

}

func main() {

    fout := myLib2.CreateFile("./test2.txt")

    defer fout.Close() //main函数结束前， 关闭文件

    outstr := fmt.Sprintf("%s:%d\n", "Hello go", 1)
    myLib2.WriteString(fout, outstr)         //写入string信息到文件
    myLib2.WriteByte(fout, []byte("abcd\n")) //写入byte类型的信息到文件

    //将标准输入写入文件
    var a string
    fmt.Println("请输入a: ")
    fmt.Scan(&a) //从标准输入设备中读取内容，放在a中
    fmt.Println("a = ", a)
    myLib2.WriteString(fout, a)

    //读文件
    myLib2.ReadFile("./test.txt")
    myLib2.ReadFileLine("./test.txt")
}

文件拷贝

package main

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

func main() {
    list := os.Args //获取命令行参数
    if len(list) != 3 {
        fmt.Println("参数不正确")
        return
    }

    srcFileName := list[1]
    dstFileName := list[2]
    if srcFileName == dstFileName {
        fmt.Println("源文件和目的文件名字不能相同")
        return
    }

    //只读方式打开源文件
    sF, err1 := os.Open(srcFileName)
    if err1 != nil {
        fmt.Println("err1 = ", err1)
        return
    }

    //新建目的文件
    dF, err2 := os.Create(dstFileName)
    if err2 != nil {
        fmt.Println("err2 = ", err2)
        return
    }

    //操作完毕，需要关闭文件
    defer sF.Close()
    defer dF.Close()

    //核心处理，从源文件读取内容，往目的文件写，读多少写多少
    buf := make([]byte, 4*1024) //4k大小临时缓冲区
    for {
        n, err := sF.Read(buf) //从源文件读取内容
        if err != nil {
            if err == io.EOF { //文件读取完毕
                break
            }else{
                fmt.Println("err = ", err)
            }
        }
        //往目的文件写，读多少写多少
        dF.Write(buf[:n])
    }
    fmt.Println("拷贝完成！")
}