golang close file

When programming in Golang, we usually need to open, read and write files. However, at the same time, we also need to ensure that we close the file when we are done using it to free up system resources. Therefore, this article will introduce how to close files in Golang.

The importance of closing files

In Golang, use the os.Open() function to open the file, use os.Create() Function can create new files. These functions return instances of type *File. When we are finished using it, we should use the file.Close() function to close the file to release system resources. Otherwise, the file descriptor will leak and eventually the entire system resources will be consumed.

For example, in the following example, we open a file and iterate through all its lines:

file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

Notice that a defer statement is used here, which will be used in the function Automatically execute the file.Close() method before returning. This way ensures that even if an error occurs in the function, the file will be closed correctly.

File closing error

We can use the file.Close() method to close the file. However, sometimes closing a file can go wrong. For example, in the following code, we intentionally open a file that does not exist:

file, err := os.Open("does_not_exist.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

Since the file does not exist, an error is returned when opening the file. In this case, file.Close() will trigger another error, causing the close to fail. In this case, we need to make sure we check for errors before closing the file. For example:

file, err := os.Open("does_not_exist.txt")
if err != nil {
    log.Fatal(err)
}
defer func() {
    if err := file.Close(); err != nil {
        log.Fatal(err)
    }
}()

Here, we use an anonymous function and place the file closing operation in this function. While the function is executing, we again check if an error occurred while closing the file. If the shutdown fails, we can call the log.Fatal() function to log the error and exit the program.

The underlying implementation of os.File.Close()

In the underlying implementation, closing the file is just an operating system call, calling the close() system function to close the file Descriptor. In Golang, the os.File type implements the io.Closer interface. There is only one method in this interface:

type Closer interface {
    Close() error
}

in os.File, the Close() function actually simply calls the syscall.Close() function.

func (file *File) Close() error {
    if file == nil {
        return syscall.EINVAL
    }
    if file == os.Stdin || file == os.Stdout || file == os.Stderr {
        return nil
    }
    return file.file.close()
}

Notice that the Close() function also checks some special conditions, for example file can be nil, or special standard input output stream. In these cases, the shutdown operation doesn't actually perform any real action.

Close resources by defer

It is a good programming practice to use the defer keyword when opening a file. This way, we can ensure that the file is closed even if an error occurs before the function returns. For example, the following code will automatically close the file after reading it:

file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// 读取文件

Since the execution order of defer statements is "last in first out", at any time before the function returns , we can all make sure the file is closed.

Conclusion

In Golang, use the os.Open() function to open the file, and use the file.Close() method to close the file to release resources. We should make sure to check for errors and log them when closing the file. Additionally, using the defer keyword ensures that when a file is used and manipulated, it is always closed properly.

The above is the detailed content of golang close file. For more information, please follow other related articles on the PHP Chinese website!