What is the go language eof error?

In the Go language, eof refers to the end of file error. It is the most important error variable in the Go language. It exists in the io package and is used to indicate the end of the input stream. Because every file has an end, "io.EOF" is often not considered an error. It is more important to indicate the end of an input stream.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

golang End of File Error (EOF)

Functions often return multiple errors, which can be interesting to end users, But for programs, this complicates the situation. Many times, programs must respond differently depending on the type of error. Let us consider an example:

Read n bytes from a file. If n is equal to the length of the file, any error in the reading process indicates failure. If n is less than the length of the file, the caller will repeatedly read fixed-size data until the end of the file. This results in the caller having to handle various errors caused by end-of-file separately.

For this reason, io package ensures that any read failure caused by the end of the file returns the same error - io.EOF, which is defined in the io package:

package io
import "errors"
// EOF is the error returned by Read when no more input is available.
var EOF = errors.New("EOF")

Understand io.EOF

io.EOF is a variable in the io package, indicating the end of file error:

package io23var EOF = errors.New("EOF")

Also view the detailed documentation through the following command:

$ go doc io.EOF
var EOF = errors.New("EOF")
EOF is the error returned by Read when no more input is available. Functions
should return EOF only to signal a graceful end of input. If the EOF occurs
unexpectedly in a structured data stream, the appropriate error is either
ErrUnexpectedEOF or some other error giving more detail.
$

io.EOF is probably the most important error variable in the Go language. It is used to indicate the end of the input stream. Because each file has an end, io.EOF is not an error in many cases, it is more important to indicate the end of an input stream.

Defects in the design of io.EOF

Unfortunately, the design of io.EOF in the standard library is problematic. First of all, EOF is End- The abbreviation of Of-File. According to the convention of Go language, capital letter abbreviations generally represent constants. Unfortunately, io.EOF was mistakenly defined as a variable, which led to the proliferation of API permissions. Minimizing API permissions is the design of any module or function. The highest requirement. By minimizing permissions, unnecessary errors in the code can be discovered as early as possible.

For example, an important security design of the Go language is to prohibit implicit type conversion. Therefore, with this design we can easily Discover bugs in the program. In addition, the Go language prohibits the definition of unused local variables (except function parameters, so function parameters are a part of the function interface) and prohibits the import of unused packages, which are best practices for minimizing permissions. The design of these minimum API permissions not only improves the quality of the program, but also improves the performance of the compilation tool and the output target file.

Because EOF is defined as a variable, this causes the variable to be maliciously Change. The following code is an elegant way to bury the trap:

func init() {2    io.EOF = nil3}

Although this is a joke, it truly exposes the design flaw of the EOF interface: it has serious security risks. Variable type It also seems to imply that users can safely modify the value of the variable. Therefore, EOF is an unsafe and elegant design.

io.EOF is changed to a constant

An obvious improvement idea is to define io.EOF as a constant. However, because EOF corresponds to an error interface type, and the current constant syntax of the Go language does not support defining interfaces of constant types. But we can pass There are some tricks to bypass this restriction.

The constants in Go language have the main types of bool/int/float/string/nil. Constants not only do not include complex types such as interfaces, but also arrays or structures of constants. Body is not supported! However, there is an important extension rule for constants: new types defined with bool/int/float/string/nil as the basic type also support constants.

For example, we redefine a string type , it can also support constants:

type MyString string2const name MyString = "chai2010"

In this example, MyString is a newly defined type, and constants of this type can be defined because its underlying string type supports constants.

So what is the underlying type of io.EOF? EOF is defined through errors.New("EOF"). The following is the implementation of this function:

package errors 
// New returns an error that formats as the given text. 
func New(text string) error {
    return &errorString{text} 
} 

// errorString is a trivial implementation of error. 
type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

So the underlying type of io.EOF is errors .errorString structure. The structure type does not support defining constants. However, there is only one string type in the errors.errorString structure, and the error string corresponding to io.EOF is "EOF".

We A new error type with string as the underlying type can be re-implemented for EOF:

package io

type errorString string

func (e errorString) Error() string {
    return string(e)
}

This new io.errorString implements two characteristics: first, it satisfies the error interface; second, it is re-implemented based on the string type Definition, therefore supports the definition of constants. Therefore, we can redefine io.EOF as a constant based on errorString:

const EOF = errorString("EOF")

In this way, EOF becomes a constant type that can be determined at compile time, and the value of the constant is still "EOF" String. But it also brings new problems: EOF is no longer an interface type, will it destroy the compatibility of old code?

【Related recommendations: Go video tutorial, Programming teaching】

The above is the detailed content of What is the go language eof error?. For more information, please follow other related articles on the PHP Chinese website!