convey-aura

1. Incorrect basic concepts

Error interface type

Philosophy of Error Handling

2. Incorrect creation method

2.1 errors. New() - Create simple errors

Errors. New() is the most basic error creation function in Go language, used to create simple error values. Its main features are:

Simple and straightforward: Accept a string parameter and return an error interface value

Sentinel Error: A predefined error variable used to represent specific error conditions, such as io.EOF, sql.ErrNoRows, etc

Immutability: The error values created are immutable and can be safely used in multiple places

Performance optimization: The same string content may return the same error instance (depending on the specific implementation)

Error identification: Determine specific error types by comparing error values

Applicable scenarios:

Create pre-defined error constants

Simple error condition judgment

Simple error situations that do not require additional contextual information

Code example:

2.2 fmt. Erref() - Format Error (Supports Packaging)

Fmt. Erref() is the main way to create formatting errors in Go language, and compared to errors. New(), it has the following important features:

Format function: supports the use of format verbs (such as% s,% d,% v, etc.) to create error messages containing dynamic information

Error packaging: By using the% w verb, underlying errors can be packaged into new errors, forming an error chain that preserves complete error tracing information. It will enable newly created errors to implement the Unwrap() method, thereby supporting error chain checking for errors. Is() and errors. As().

Context addition: capable of adding meaningful contextual information based on the original error

Applicable scenarios:

When dynamic information needs to be added to errors

When it is necessary to package underlying errors and add context

Building a clear error chain for debugging and problem localization

Code example:

2.3 Custom Error Types

Custom error types are advanced features of Go error handling, allowing the creation of error structures that contain rich information. Compared to simple errors, custom error types have the following advantages:

Rich context: can include additional information such as error codes, timestamps, detailed descriptions, etc

Structured data: Errors themselves can carry structured data, making it easier for programs to process

Type safety: Distinguishing different types of errors through a type system

Behavior extension: can add methods for error types to achieve more complex error handling logic

Design principles:

Implement error interface: Custom types must implement the Error () string method

Optional Unwrap method: If support for error chains is required, the Unwrap() error method can be implemented

Immutability: Error values should be immutable after creation

Clear structure: Error fields should clearly express the essential information of the error

Applicable scenarios:

Complex applications that require carrying structured error information

API error handling requires standardized error responses

A system that requires misclassification and grading

Scenarios requiring error statistics and analysis

summary

Error creation: Use errors. New to create simple errors, fmt. Error to create formatted errors (supports% w wrapper)

Error checking:

Errors. Is(): Check for specific error values in the error chain

Errors. As(): Extract specific error types from the error chain

Error handling principles:

Handle promptly and do not overlook errors

Add meaningful contextual information

Using incorrect packaging to form a clear chain of errors

Best practices:

Clearly defined sentinel error

Customize error types to carry more information

Classify and handle different types of errors

Appropriate error recovery mechanism