GO文件操作

文件操作案例

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

//写入方式一
func main01() {
    //路径分为绝对路径和相对路径
    //create，文件存在则会覆盖原始内容（其实就相当于清空），不存在则创建
    fp, error := os.Create("./a.txt")
    if error != nil {
        fmt.Println("文件创建失败!")
        return
    }
    //延迟调用，关闭文件
    defer fp.Close()
    //写入文件,windows上面换行\r\n其他\n即可
    fp.WriteString("hello\r\n")
    n, _ := fp.WriteString("world\r\n")
    fmt.Println(n) //7 其实就是写入的内容长度world\r\n刚好7
}

//写入方式二
func main2() {
    fp, error := os.Create("./a.txt")
    if error != nil {
        fmt.Println("文件创建失败!")
        return
    }
    defer fp.Close()
    b := []byte{'h', 'e', 'l', 'l'}
    fp.Write(b)
    str := "world"
    //字符串和切片允许相互转换
    b1 := []byte(str)
    fp.Write(b1)
}

//写入方式三：指定位置
func main3() {
    //os.Open是只读打开

    /**
    读写方式：
    O_APPEND：追加
    O_RDONLY: 只读
    O_RDWR:可读可写
    O_WRONLY:只写
    */

    //第三个参数是权限，取值范围0-7
    /**
    0：没有任何权限
    1：执行权限(如果是可执行文件，是可以运行的)
    2：写权限
    3:写权限与执行权限
    4：读权限
    5:读权限与执行权限
    6:读权限与写权限
    7:读权限，写权限，执行权限
    */
    //OpenFile无法创建文件
    fp, error := os.OpenFile("./a.txt", os.O_RDWR, 6)
    if error != nil {
        fmt.Println("文件创建失败!")
        return
    }
    defer fp.Close()
    //b:=[]byte("hello")
    //执行前内容aaaaa
    //执行后内容ahello
    //fp.WriteAt(b,1)

    //获取文件字符个数,参数一可以是负数，这样可以往左偏移
    n, _ := fp.Seek(0, io.SeekEnd)
    b := []byte("hello")
    //此时就相当于追加了，因为n此时是内容总长度了
    fp.WriteAt(b, n) //ahellohello

}

//读取文件
func main4() {
    fp, error := os.Open("./a.txt")
    if error != nil {
        /**
        系统打开文件个数限制是65535
        所以重复打开同一文件是可以的

        1. 文件不存在
        2. 文件权限
        3. 文件打开上限
        */
        fmt.Println("文件打开失败!")
        return
    }
    defer fp.Close()

    b := make([]byte, 1024)
    //n, error := fp.Read(b)
    //fmt.Println(n) //n是长度
    fp.Read(b)

    //也可以通过for遍历读取
    fmt.Println(string(b)) //ahellohello
}

func main5() {
    fp, error := os.Open("./a.txt")
    if error != nil {
        fmt.Println("文件打开失败!")
        return
    }
    defer fp.Close()
    b := make([]byte, 20)
    for {
        n, err := fp.Read(b)
        //文件结束
        if err == io.EOF { //-1
            break
        }
        fmt.Print(string(b[:n]))
    }
}

func main() {
    fp, error := os.Open("./a.txt")
    if error != nil {
        fmt.Println("文件打开失败!")
        return
    }
    defer fp.Close()
    //行读取。新建缓冲区，把内容先放到缓冲区
    r := bufio.NewReader(fp)
    for {
        buf, err := r.ReadBytes('\n')
        fmt.Print(string(buf))

        //文件结束，此时必须读取在上面，否则最后一行的时候err == io.EOF，则永远会少读取一行
        if err == io.EOF { //-1
            break
        }
    }
}

拷贝文件

func main() {

    // 打开读文件
    f_r, err := os.Open("C:/z1/测试.avi")
    if err != nil {
        fmt.Println("Open err: ", err)
        return
    }
    defer f_r.Close()
    // 创建写文件
    f_w, err := os.Create("C:/z1/test.avi")
    if err != nil {
        fmt.Println("Create err: ", err)
        return
    }
    defer f_w.Close()

    // 从读文件中获取数据，放到缓冲区中。
    buf := make([]byte, 4096)
    // 循环从读文件中，获取数据，“原封不动的”写到写文件中。
    for {
        n, err := f_r.Read(buf)
        if err != nil && err == io.EOF {
            fmt.Printf("读完。n = %d\n", n)
            return
        }
        f_w.Write(buf[:n]) // 读多少，写多少
    }
}

目录操作

打开目录

OpenFile：以只读方式打开目录

• 参1：name， 打开目录的路径： 绝对路径、相对路径
• 参2：打开目录权限： O_RDONLY
• 参3：os.ModeDir,
  返回值： 返回一个可以读目录的 文件指针。

读目录：Readdir

原型：func (f *File) Readdir(n int) ([]FileInfo, error) {
            
参数: 欲打开的目录项个数。 -1 ， 表所有;例如10，则只读取十个目录项

返回值：  FileInfo ：    
type FileInfo interface {
    Name() string               // base name of the file
    Size() int64                // length in bytes for regular files; system-dependent for others
    Mode() FileMode             // file mode bits
    ModTime() time.Time     // modification time
    IsDir() bool                // abbreviation for Mode().IsDir()
    Sys() interface{}           // underlying data source (can return nil)
}   

代码案例

func main()  {
    // 获取用户输入的目录路径
    fmt.Println("请输入待查询的目录：")
    var path string
    fmt.Scan(&path)

    // 打开目录
    f, err := os.OpenFile(path, os.O_WRONLY, os.ModeDir)
    if err != nil {
        fmt.Println("OpenFile err: ", err)
        return
    }
    defer f.Close()
    // 读取目录项
    info, err:= f.Readdir(-1)   // -1： 读取目录中所有目录项
    if err != nil {
        fmt.Println("Readdir err: ", err)
        return
    }
    // 变量返回的切片
    for _, fileInfo := range info {
        if fileInfo.IsDir() {           // 是目录
            fmt.Println(fileInfo.Name(), " 是一个目录")
        } else {
            fmt.Println(fileInfo.Name(), " 是一个文件")
        }
    }
}

MMU

虚拟内存映射单元

MMU.png

缓冲区

缓冲区.png

文件读写分为，系统缓存和用户缓冲，用户缓存就是写代码时候创建的缓存，而用户缓存则是系统内部的缓存调度，不是每次读写都是操作磁头扇区等硬件，而是系统尽可能的预读入缓输出，减少硬件交互，代码的读取和写入都是读取和写入系统缓冲区，真正什么时候写入硬盘，有系统内部IO优化算法操作。

结构体指针传参

结构体指针传参.png