go语言——文件处理(Go language – file processing)-go

发表于： 5月 14, 2022 5月 14, 2022
分类：编程
标签： go

go语言——文件处理(Go language – file processing)

创建文件

import (
    "fmt"
    "os"
)

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }

    //对文件进行操作

    //关闭 defer表示延迟执行
    defer file.Close()
}

WriteString方法

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    n, err := file.WriteString("aaaaaaaaaaa")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
}

Write方法

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    var str string = "Hello Wprld"
    n, err := file.Write([]byte(str)) //需要将字符串转换成字节切片
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
}

WriteAt方法，是在指定位置写入文件内容

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    var str string = "Hello World002"
    file.WriteString("Hello World001")
    n, err := file.WriteAt([]byte(str), 2) //第二个参数表示指定位置写入数据
    if err != nil {
        fmt.Println(err)
    }
    fmt.Print(n)
}

openFile方法

openFile有3个参数，

第一个参数表示打开文件的路径，

第二个参数表示：模式，常见的模式有O_RDONLY(只读模式)，O_WRONLY(只写模式)，O_RDWR（可读可写），O_APPEND（追加模式）

O_RDWR：在文件开头进行替换

O_WRONLY：在文件开头进行替换

O_APPEND：在文件末尾处进行追加

第三个参数表示：权限，取值范围（0——7）

表示如下：

0：表示没有任何权限

1：执行权限

2：写权限

4：读权限

其他数字为1,2,4权限相互组合

func main() {
    file, err := os.OpenFile("D:/Test/a.txt", os.O_APPEND, 6)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    num, err := file.WriteString("Hello World001")
    fmt.Println("num = ", num)
    if err != nil {
        fmt.Println(err)
    }
}

文件读取

open方法与openFile方法的不同

open方法是封装openFile方法的方法，open方法直接return OpenFile(name, os.O_RDONLY, 0)

func main() {
    //1.打开要读取的文件
    file, err := os.OpenFile("D:/Test/a.txt", os.O_RDONLY, 0)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //2.顶一个字符切片，存储从文件中读取的数据
    buffer := make([]byte, 1024*2)
    n, err := file.Read(buffer)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
    fmt.Println(string(buffer[:n]))
}

func main() {
    //1.打开要读取的文件
    file, err := os.OpenFile("D:/Test/a.txt", os.O_RDONLY, 0)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //2.顶一个字符切片，存储从文件中读取的数据
    buffer := make([]byte, 10)
    for {
        n, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        fmt.Println(string(buffer[:n]))
    }

文件备份

func main() {
    //1.打开要读取的文件
    file1, err := os.Open("D:/Test/a.txt")
    if err != nil {
        fmt.Println(err)
    }
    defer file1.Close()
    //2.创建一个新的文件
    file2, err := os.Create("D:/Test/b.txt")
    if err != nil {
        fmt.Println(err)
    }
    defer file2.Close()

    //3.顶一个字符切片，存储从文件中读取的数据
    buffer1 := make([]byte, 10)
    for {
        n, err := file1.Read(buffer1)
        if err == io.EOF {
            break
        }
        file2.Write(buffer1[:n])
    }
}

————————

create a file

import (
    "fmt"
    "os"
)

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }

    //对文件进行操作

    //关闭 defer表示延迟执行
    defer file.Close()
}

WriteString方法

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    n, err := file.WriteString("aaaaaaaaaaa")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
}

Write方法

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    var str string = "Hello Wprld"
    n, err := file.Write([]byte(str)) //需要将字符串转换成字节切片
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
}

The writeat method writes the contents of the file at the specified location

func main() {
    //创建文件时，需要指定文件的存储路径以及文件名称
    file, err := os.Create("D:/Test/a.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //对文件进行操作
    var str string = "Hello World002"
    file.WriteString("Hello World001")
    n, err := file.WriteAt([]byte(str), 2) //第二个参数表示指定位置写入数据
    if err != nil {
        fmt.Println(err)
    }
    fmt.Print(n)
}

openFile方法

OpenFile has three parameters,

The first parameter indicates the path to open the file,

The second parameter indicates the mode. The common modes are o_ Rdonly (read only mode), O_ Wronly, O_ Rdwr (readable and writable), O_ Append (append mode)

O_ Rdwr: replace at the beginning of the file

O_ Wronly: replace at the beginning of the file

O_ Append: append at the end of the file

The third parameter indicates: permission, value range (0-7)

Expressed as follows:

0: no permission

1: Execution Authority

2: Write permission

4: Read permission

Other numbers are 1, 2 and 4 permissions combined with each other

func main() {
    file, err := os.OpenFile("D:/Test/a.txt", os.O_APPEND, 6)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    num, err := file.WriteString("Hello World001")
    fmt.Println("num = ", num)
    if err != nil {
        fmt.Println(err)
    }
}

File reading

The difference between the open method and the openFile method

The open method encapsulates the openFile method. The open method directly returns openFile (name, OS. O_rdonly, 0)

func main() {
    //1.打开要读取的文件
    file, err := os.OpenFile("D:/Test/a.txt", os.O_RDONLY, 0)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //2.顶一个字符切片，存储从文件中读取的数据
    buffer := make([]byte, 1024*2)
    n, err := file.Read(buffer)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(n)
    fmt.Println(string(buffer[:n]))
}

func main() {
    //1.打开要读取的文件
    file, err := os.OpenFile("D:/Test/a.txt", os.O_RDONLY, 0)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()
    //2.顶一个字符切片，存储从文件中读取的数据
    buffer := make([]byte, 10)
    for {
        n, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        fmt.Println(string(buffer[:n]))
    }

File backup

func main() {
    //1.打开要读取的文件
    file1, err := os.Open("D:/Test/a.txt")
    if err != nil {
        fmt.Println(err)
    }
    defer file1.Close()
    //2.创建一个新的文件
    file2, err := os.Create("D:/Test/b.txt")
    if err != nil {
        fmt.Println(err)
    }
    defer file2.Close()

    //3.顶一个字符切片，存储从文件中读取的数据
    buffer1 := make([]byte, 10)
    for {
        n, err := file1.Read(buffer1)
        if err == io.EOF {
            break
        }
        file2.Write(buffer1[:n])
    }
}