How to use Go for file operations?

The Go language is an open source programming language for writing efficient, modern programs. Due to its simple syntax structure and efficient execution efficiency, it has become the choice of more and more programmers. The Go language provides a wealth of file operation methods, which allows us to complete tasks quickly and efficiently when processing files.

This article will introduce how to use Go language for file operations. The main contents include the following aspects:

1. Create files and read files
2. Write files and close files
3. Rename/Move files
4. Delete files and directories
5. Get file or directory information

Before starting to introduce the specific operations of each aspect, please ensure that you have installed the Go language development environment and configured the path .

1. Creating files and reading files

The most basic way to create a file in Go language is to use the os.Create() function, which returns a file pointer and possible errors.

For example:

file, err := os.Create("test.txt")
if err != nil {
    fmt.Println(err)
    return
}
defer file.Close()

The above code will create a file named test.txt and return a file pointer. If there is an error, an error message will be printed.

Use the os.Open() function to open an existing file. It will also return a file pointer and possible errors.

For example:

file, err := os.Open("test.txt")
if err != nil {
    fmt.Println(err)
    return
}
defer file.Close()

The above code will open the file named test.txt and return a pointer. If the file does not exist or an error occurs, an error message will be printed.

The most basic way to read a file is to use the bufio.NewReader() function and ReadString() method.

For example:

file, err := os.Open("test.txt")
if err != nil {
    fmt.Println(err)
    return
}
defer file.Close()

reader := bufio.NewReader(file)

for {
    line, err := reader.ReadString('
')
    if err == io.EOF {
        break
    } else if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Print(line)
}

The above code uses the bufio.NewReader() function to create a new reader, and then uses the ReadString() method to read each line. When the end of file is encountered, err becomes io.EOF.

2. Writing and closing files

The basic way to write files in Go language is to use the os.OpenFile() function to create a file pointer, and then use WriteString() method writes the content and finally closes the file.

For example:

file, err := os.OpenFile("test.txt", os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
    fmt.Println(err)
    return
}
defer file.Close()

file.WriteString("Hello World!")

The above code will use the os.OpenFile() function to create a file named test.txt, and use os.O_RDWR and os.O_CREATE to open the file for reading and writing. Create permission, 0644 represents the permission bit. Then use the WriteString() method to write the "Hello World!" string to the file.

3. Rename/Move Files

Use the os.Rename() function in Go language to rename or move files.

For example:

err := os.Rename("test.txt", "new.txt")
if err != nil {
    fmt.Println(err)
    return
}

The above code renames the test.txt file to new.txt.

4. Delete files and directories

The basic way to delete files in Go language is to use the os.Remove() function, which will delete the specified file or directory.

For example:

err := os.Remove("new.txt")
if err != nil {
    fmt.Println(err)
    return
}

The above code will delete the new.txt file.

5. Get file or directory information

In Go language, you can get file or directory information through the os.Stat() function.

For example:

info, err := os.Stat("test.txt")
if err != nil {
    fmt.Println(err)
    return
}

fmt.Println("File name:", info.Name())
fmt.Println("Size in bytes:", info.Size())
fmt.Println("Permissions:", info.Mode())
fmt.Println("Last modified:", info.ModTime())

The above code uses the os.Stat() function to obtain the information of the test.txt file, and then outputs the file name, file size, file permissions, and last modification time.

Summary

Through the introduction of this article, we have learned how to use Go language for file operations. Including operations such as creating files, reading files, writing files, closing files, renaming/moving files, deleting files and directories, and obtaining file or directory information.

In actual development, we often need to process a large number of files. The Go language provides a simple and efficient file operation method, allowing us to complete file operation tasks quickly and accurately.

The above is the detailed content of How to use Go for file operations?. For more information, please follow other related articles on the PHP Chinese website!