自定义错误类型详解 - Golang基础面试题

Go语言鼓励创建自定义错误类型来提供更丰富的错误信息和更好的错误处理体验。本章深入探讨如何设计和实现自定义错误类型。

📋 重点面试题

面试题 1：自定义错误类型的基本实现

难度级别：⭐⭐⭐
考察范围：接口实现/错误设计
技术标签：custom errors error interface error types error methods

问题分析

自定义错误类型通过实现error接口来提供更详细的错误信息，是构建健壮Go应用的重要技能。

详细解答

1. 简单自定义错误类型

基础实现错误处理

package main

import (
    "fmt"
    "strconv"
    "time"
)

// 1. 最简单的自定义错误类型
type MyError string

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

// 2. 结构体错误类型
type ValidationError struct {
    Field   string
    Value   interface{}
    Message string
}

func (ve *ValidationError) Error() string {
    return fmt.Sprintf("validation failed for field '%s' with value '%v': %s",
        ve.Field, ve.Value, ve.Message)
}

// 3. 带有错误码的错误类型
type APIError struct {
    Code    int
    Message string
    Details map[string]interface{}
}

func (ae *APIError) Error() string {
    return fmt.Sprintf("API Error %d: %s", ae.Code, ae.Message)
}

func (ae *APIError) GetCode() int {
    return ae.Code
}

func (ae *APIError) GetDetails() map[string]interface{} {
    return ae.Details
}

func demonstrateBasicCustomErrors() {
    fmt.Println("=== 基本自定义错误类型 ===")
    
    // 使用简单自定义错误
    var simpleErr error = MyError("这是一个简单的自定义错误")
    fmt.Printf("简单错误: %v\n", simpleErr)
    fmt.Printf("错误类型: %T\n", simpleErr)
    
    // 使用结构体错误
    validationErr := &ValidationError{
        Field:   "email",
        Value:   "invalid-email",
        Message: "email format is invalid",
    }
    fmt.Printf("验证错误: %v\n", validationErr)
    
    // 使用API错误
    apiErr := &APIError{
        Code:    404,
        Message: "Resource not found",
        Details: map[string]interface{}{
            "resource_id": "user123",
            "timestamp":   time.Now(),
        },
    }
    fmt.Printf("API错误: %v\n", apiErr)
    fmt.Printf("错误码: %d\n", apiErr.GetCode())
    fmt.Printf("错误详情: %v\n", apiErr.GetDetails())
}

// 网络错误类型
type NetworkError struct {
    Op      string
    URL     string
    Timeout bool
    Temporary bool
    Err     error
}

func (ne *NetworkError) Error() string {
    return fmt.Sprintf("network error during %s to %s: %v", ne.Op, ne.URL, ne.Err)
}

func (ne *NetworkError) IsTimeout() bool {
    return ne.Timeout
}

func (ne *NetworkError) IsTemporary() bool {
    return ne.Temporary
}

func (ne *NetworkError) Unwrap() error {
    return ne.Err
}

// 数据库错误类型
type DatabaseError struct {
    Operation string
    Table     string
    Query     string
    Err       error
}

func (de *DatabaseError) Error() string {
    return fmt.Sprintf("database error during %s on table %s: %v", 
        de.Operation, de.Table, de.Err)
}

func (de *DatabaseError) Unwrap() error {
    return de.Err
}

func demonstrateErrorTypeHandling() {
    fmt.Println("\n=== 错误类型判断和处理 ===")
    
    errors := []error{
        &ValidationError{Field: "age", Value: -1, Message: "age must be positive"},
        &APIError{Code: 500, Message: "Internal server error"},
        &NetworkError{Op: "GET", URL: "https://api.example.com", Timeout: true, Err: fmt.Errorf("connection timeout")},
        &DatabaseError{Operation: "SELECT", Table: "users", Query: "SELECT * FROM users", Err: fmt.Errorf("connection lost")},
        fmt.Errorf("generic error"),
    }
    
    for i, err := range errors {
        fmt.Printf("\n--- 处理错误 %d ---\n", i+1)
        handleError(err)
    }
}

func handleError(err error) {
    fmt.Printf("原始错误: %v\n", err)
    
    // 使用类型断言处理不同类型的错误
    switch e := err.(type) {
    case *ValidationError:
        fmt.Printf("验证错误处理:\n")
        fmt.Printf("  字段: %s\n", e.Field)
        fmt.Printf("  值: %v\n", e.Value)
        fmt.Printf("  建议: 检查输入参数\n")
        
    case *APIError:
        fmt.Printf("API错误处理:\n")
        fmt.Printf("  状态码: %d\n", e.Code)
        if e.Code >= 500 {
            fmt.Printf("  建议: 服务器内部错误，稍后重试\n")
        } else if e.Code >= 400 {
            fmt.Printf("  建议: 客户端错误，检查请求参数\n")
        }
        
    case *NetworkError:
        fmt.Printf("网络错误处理:\n")
        fmt.Printf("  操作: %s\n", e.Op)
        fmt.Printf("  URL: %s\n", e.URL)
        if e.IsTimeout() {
            fmt.Printf("  建议: 网络超时，可以重试\n")
        }
        if e.IsTemporary() {
            fmt.Printf("  建议: 临时网络问题，建议重试\n")
        }
        
    case *DatabaseError:
        fmt.Printf("数据库错误处理:\n")
        fmt.Printf("  操作: %s\n", e.Operation)
        fmt.Printf("  表: %s\n", e.Table)
        fmt.Printf("  建议: 检查数据库连接和SQL语句\n")
        
    default:
        fmt.Printf("通用错误处理: %T\n", err)
        fmt.Printf("  建议: 记录日志并返回通用错误信息\n")
    }
}
::: code-group

```text [方案一]

3. 错误工厂函数

点击查看完整代码实现


```text [错误处理]

面试题 2：错误链和错误包装

难度级别：⭐⭐⭐⭐
考察范围：错误包装/Go 1.13+特性
技术标签：error wrapping error chains errors.Unwrap fmt.Errorf %w

问题分析

错误包装允许在保持原始错误信息的同时添加上下文，是现代Go错误处理的重要特性。

详细解答

1. 支持错误包装的自定义错误

点击查看完整代码实现


:::go
import (
    "errors"
)

// 支持错误包装的服务错误
type ServiceError struct {
    Service   string
    Operation string
    Message   string
    Cause     error
}

func (se *ServiceError) Error() string {
    if se.Cause != nil {
        return fmt.Sprintf("%s service %s operation failed: %s (caused by: %v)",
            se.Service, se.Operation, se.Message, se.Cause)
    }
    return fmt.Sprintf("%s service %s operation failed: %s",
        se.Service, se.Operation, se.Message)
}

func (se *ServiceError) Unwrap() error {
    return se.Cause
}

// 多层错误包装
type BusinessError struct {
    Code        string
    UserMessage string
    Details     map[string]interface{}
    Cause       error
}

func (be *BusinessError) Error() string {
    return fmt.Sprintf("business error [%s]: %s", be.Code, be.UserMessage)
}

func (be *BusinessError) Unwrap() error {
    return be.Cause
}

func (be *BusinessError) GetCode() string {
    return be.Code
}

func (be *BusinessError) GetUserMessage() string {
    return be.UserMessage
}

func NewBusinessError(code, userMsg string) *BusinessError {
    return &BusinessError{
        Code:        code,
        UserMessage: userMsg,
        Details:     make(map[string]interface{}),
    }
}

func (be *BusinessError) WithCause(err error) *BusinessError {
    be.Cause = err
    return be
}

func (be *BusinessError) WithDetail(key string, value interface{}) *BusinessError {
    be.Details[key] = value
    return be
}

func demonstrateErrorWrapping() {
    fmt.Println("\n=== 错误包装和错误链 ===")
    
    // 创建底层错误
    originalErr := errors.New("connection refused")
    
    // 第一层包装
    networkErr := &NetworkError{
        Op:  "connect",
        URL: "database:5432",
        Err: originalErr,
    }
    
    // 第二层包装
    serviceErr := &ServiceError{
        Service:   "user",
        Operation: "create",
        Message:   "failed to save user to database",
        Cause:     networkErr,
    }
    
    // 第三层包装
    businessErr := NewBusinessError("USER_CREATION_FAILED", "用户创建失败，请稍后重试").
        WithCause(serviceErr).
        WithDetail("user_id", "user123").
        WithDetail("timestamp", time.Now())
    
    fmt.Printf("完整错误链: %v\n", businessErr)
    
    // 使用errors.Is检查错误链
    fmt.Printf("包含原始错误: %t\n", errors.Is(businessErr, originalErr))
    
    // 使用errors.As获取特定类型错误
    var netErr *NetworkError
    if errors.As(businessErr, &netErr) {
        fmt.Printf("找到NetworkError: %s %s\n", netErr.Op, netErr.URL)
    }
    
    var svcErr *ServiceError
    if errors.As(businessErr, &svcErr) {
        fmt.Printf("找到ServiceError: %s.%s\n", svcErr.Service, svcErr.Operation)
    }
    
    // 手动遍历错误链
    fmt.Println("\n错误链遍历:")
    currentErr := error(businessErr)
    level := 1
    for currentErr != nil {
        fmt.Printf("  第%d层: %T - %v\n", level, currentErr, currentErr)
        
        // 获取下一层错误
        if unwrapper, ok := currentErr.(interface{ Unwrap() error }); ok {
            currentErr = unwrapper.Unwrap()
        } else {
            break
        }
        level++
    }
}

:::

2. 自定义错误链遍历

点击查看完整代码实现

// 错误链遍历器
type ErrorChain struct {
    errors []error
}

func NewErrorChain(err error) *ErrorChain {
    var errors []error
    current := err
    
    for current != nil {
        errors = append(errors, current)
        
        if unwrapper, ok := current.(interface{ Unwrap() error }); ok {
            current = unwrapper.Unwrap()
        } else {
            break
        }
    }
    
    return &ErrorChain{errors: errors}
}

func (ec *ErrorChain) All() []error {
    return ec.errors
}

func (ec *ErrorChain) Root() error {
    if len(ec.errors) == 0 {
        return nil
    }
    return ec.errors[len(ec.errors)-1]
}

func (ec *ErrorChain) Top() error {
    if len(ec.errors) == 0 {
        return nil
    }
    return ec.errors[0]
}

func (ec *ErrorChain) FindType(target interface{}) (error, bool) {
    for _, err := range ec.errors {
        if errors.As(err, target) {
            return err, true
        }
    }
    return nil, false
}

func (ec *ErrorChain) Contains(target error) bool {
    for _, err := range ec.errors {
        if errors.Is(err, target) {
            return true
        }
    }
    return false
}

func (ec *ErrorChain) String() string {
    var result []string
    for i, err := range ec.errors {
        result = append(result, fmt.Sprintf("%d: %T - %v", i+1, err, err))
    }
    return fmt.Sprintf("Error Chain (%d levels):\n%s", 
        len(ec.errors), strings.Join(result, "\n"))
}

func demonstrateErrorChainTraversal() {
    fmt.Println("\n=== 错误链遍历 ===")
    
    // 构建复杂错误链
    baseErr := errors.New("disk full")
    
    dbErr := &DatabaseError{
        Operation: "INSERT",
        Table:     "users",
        Query:     "INSERT INTO users ...",
        Err:       baseErr,
    }
    
    svcErr := &ServiceError{
        Service:   "user",
        Operation: "register",
        Message:   "user registration failed",
        Cause:     dbErr,
    }
    
    bizErr := NewBusinessError("REGISTRATION_FAILED", "注册失败").
        WithCause(svcErr).
        WithDetail("retry", true)
    
    // 使用错误链遍历器
    chain := NewErrorChain(bizErr)
    fmt.Printf("%s\n", chain.String())
    
    fmt.Printf("根错误: %v\n", chain.Root())
    fmt.Printf("顶层错误: %v\n", chain.Top())
    
    // 查找特定类型的错误
    var foundDbErr *DatabaseError
    if err, found := chain.FindType(&foundDbErr); found {
        fmt.Printf("找到数据库错误: %v\n", err)
    }
    
    // 检查是否包含特定错误
    fmt.Printf("包含baseErr: %t\n", chain.Contains(baseErr))
}
::: details 点击查看完整代码实现

:::

面试题 3：哨兵错误和错误常量

难度级别：⭐⭐⭐⭐
考察范围：错误设计模式/标准库模式
技术标签：sentinel errors error constants error variables io.EOF

问题分析

哨兵错误是预定义的错误值，用于表示特定的错误条件，是Go标准库中广泛使用的模式。

详细解答

1. 哨兵错误的定义和使用

点击查看完整代码实现

:::go
import (
    "io"
)

// 定义哨兵错误
var (
    ErrUserNotFound     = errors.New("user not found")
    ErrInvalidCredentials = errors.New("invalid credentials")
    ErrAccountLocked    = errors.New("account is locked")
    ErrEmailExists      = errors.New("email already exists")
    ErrInvalidInput     = errors.New("invalid input")
    ErrPermissionDenied = errors.New("permission denied")
    ErrServiceUnavailable = errors.New("service unavailable")
)

// 用户服务
type UserService struct {
    users map[string]*User
    locked map[string]bool
}

type User struct {
    ID       string
    Email    string
    Password string
    Active   bool
}

func NewUserService() *UserService {
    return &UserService{
        users:  make(map[string]*User),
        locked: make(map[string]bool),
    }
}

func (us *UserService) CreateUser(email, password string) error {
    if email == "" || password == "" {
        return ErrInvalidInput
    }
    
    // 检查邮箱是否已存在
    for _, user := range us.users {
        if user.Email == email {
            return ErrEmailExists
        }
    }
    
    userID := fmt.Sprintf("user_%d", len(us.users)+1)
    us.users[userID] = &User{
        ID:       userID,
        Email:    email,
        Password: password,
        Active:   true,
    }
    
    return nil
}

func (us *UserService) AuthenticateUser(email, password string) (*User, error) {
    if email == "" || password == "" {
        return nil, ErrInvalidInput
    }
    
    // 查找用户
    var foundUser *User
    var userID string
    for id, user := range us.users {
        if user.Email == email {
            foundUser = user
            userID = id
            break
        }
    }
    
    if foundUser == nil {
        return nil, ErrUserNotFound
    }
    
    // 检查账户是否被锁定
    if us.locked[userID] {
        return nil, ErrAccountLocked
    }
    
    // 检查密码
    if foundUser.Password != password {
        return nil, ErrInvalidCredentials
    }
    
    // 检查账户是否激活
    if !foundUser.Active {
        return nil, ErrPermissionDenied
    }
    
    return foundUser, nil
}

func (us *UserService) LockAccount(userID string) error {
    if _, exists := us.users[userID]; !exists {
        return ErrUserNotFound
    }
    
    us.locked[userID] = true
    return nil
}

func demonstrateSentinelErrors() {
    fmt.Println("\n=== 哨兵错误 ===")
    
    service := NewUserService()
    
    // 测试不同的错误情况
    testCases := []struct {
        name     string
        email    string
        password string
        setup    func()
    }{
        {"正常创建", "user1@example.com", "password123", func() {}},
        {"重复邮箱", "user1@example.com", "password456", func() {}},
        {"无效输入", "", "", func() {}},
        {"用户不存在", "nonexistent@example.com", "password", func() {}},
        {"账户锁定", "user1@example.com", "password123", func() {
            for id := range service.users {
                service.LockAccount(id)
                break
            }
        }},
        {"密码错误", "user1@example.com", "wrongpassword", func() {}},
    }
    
    for i, tc := range testCases {
        fmt.Printf("\n--- 测试案例 %d: %s ---\n", i+1, tc.name)
        
        tc.setup()
        
        // 创建用户
        if err := service.CreateUser(tc.email, tc.password); err != nil {
            handleUserError("创建用户", err)
        } else {
            fmt.Println("创建用户成功")
        }
        
        // 认证用户
        if user, err := service.AuthenticateUser(tc.email, tc.password); err != nil {
            handleUserError("用户认证", err)
        } else {
            fmt.Printf("用户认证成功: %s\n", user.Email)
        }
    }
}

func handleUserError(operation string, err error) {
    fmt.Printf("%s失败: %v\n", operation, err)
    
    // 使用errors.Is判断具体错误
    switch {
    case errors.Is(err, ErrUserNotFound):
        fmt.Println("  建议: 检查用户是否存在或提示用户注册")
    case errors.Is(err, ErrInvalidCredentials):
        fmt.Println("  建议: 提示用户检查密码")
    case errors.Is(err, ErrAccountLocked):
        fmt.Println("  建议: 联系管理员解锁账户")
    case errors.Is(err, ErrEmailExists):
        fmt.Println("  建议: 提示用户使用其他邮箱或登录现有账户")
    case errors.Is(err, ErrInvalidInput):
        fmt.Println("  建议: 检查输入参数是否完整")
    case errors.Is(err, ErrPermissionDenied):
        fmt.Println("  建议: 联系管理员激活账户")
    case errors.Is(err, ErrServiceUnavailable):
        fmt.Println("  建议: 稍后重试")
    default:
        fmt.Println("  建议: 联系技术支持")
    }
}
::: code-group

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

:::text [方案一]

2. 结合哨兵错误和自定义错误

点击查看完整代码实现


```text [性能优化]

面试题 4：错误处理的性能优化

难度级别：⭐⭐⭐⭐⭐
考察范围：性能优化/内存管理
技术标签：error performance memory allocation error pooling benchmarking

问题分析

错误处理的性能影响不容忽视，特别是在高并发场景下，需要考虑错误对象的创建和内存分配。

详细解答

1. 错误性能测试和优化

点击查看完整代码实现


:::go
import (
    "sync"
    "time"
)

// 性能测试用的错误类型
type SimpleError struct {
    message string
}

func (se *SimpleError) Error() string {
    return se.message
}

type ComplexError struct {
    Code      int
    Message   string
    Timestamp time.Time
    Details   map[string]interface{}
    Stack     []string
}

func (ce *ComplexError) Error() string {
    return fmt.Sprintf("Error %d: %s at %v", ce.Code, ce.Message, ce.Timestamp)
}

// 错误池化
var simpleErrorPool = sync.Pool{
    New: func() interface{} {
        return &SimpleError{}
    },
}

var complexErrorPool = sync.Pool{
    New: func() interface{} {
        return &ComplexError{
            Details: make(map[string]interface{}),
            Stack:   make([]string, 0, 10),
        }
    },
}

func NewSimpleErrorPooled(message string) *SimpleError {
    err := simpleErrorPool.Get().(*SimpleError)
    err.message = message
    return err
}

func (se *SimpleError) Release() {
    se.message = ""
    simpleErrorPool.Put(se)
}

func NewComplexErrorPooled(code int, message string) *ComplexError {
    err := complexErrorPool.Get().(*ComplexError)
    err.Code = code
    err.Message = message
    err.Timestamp = time.Now()
    
    // 清空映射但保持容量
    for k := range err.Details {
        delete(err.Details, k)
    }
    
    // 重置切片但保持容量
    err.Stack = err.Stack[:0]
    
    return err
}

func (ce *ComplexError) Release() {
    ce.Code = 0
    ce.Message = ""
    ce.Timestamp = time.Time{}
    
    // 清空但保持容量
    for k := range ce.Details {
        delete(ce.Details, k)
    }
    ce.Stack = ce.Stack[:0]
    
    complexErrorPool.Put(ce)
}

func demonstrateErrorPerformance() {
    fmt.Println("\n=== 错误性能优化 ===")
    
    const iterations = 100000
    
    // 测试1: 简单错误创建
    start := time.Now()
    for i := 0; i < iterations; i++ {
        err := &SimpleError{message: "test error"}
        _ = err.Error()
    }
    simpleTime := time.Since(start)
    
    // 测试2: 复杂错误创建
    start = time.Now()
    for i := 0; i < iterations; i++ {
        err := &ComplexError{
            Code:      500,
            Message:   "internal error",
            Timestamp: time.Now(),
            Details:   map[string]interface{}{"id": i},
            Stack:     []string{"main", "handler", "process"},
        }
        _ = err.Error()
    }
    complexTime := time.Since(start)
    
    // 测试3: 池化简单错误
    start = time.Now()
    for i := 0; i < iterations; i++ {
        err := NewSimpleErrorPooled("test error")
        _ = err.Error()
        err.Release()
    }
    pooledSimpleTime := time.Since(start)
    
    // 测试4: 池化复杂错误
    start = time.Now()
    for i := 0; i < iterations; i++ {
        err := NewComplexErrorPooled(500, "internal error")
        err.Details["id"] = i
        err.Stack = append(err.Stack, "main", "handler", "process")
        _ = err.Error()
        err.Release()
    }
    pooledComplexTime := time.Since(start)
    
    fmt.Printf("简单错误创建: %v\n", simpleTime)
    fmt.Printf("复杂错误创建: %v\n", complexTime)
    fmt.Printf("池化简单错误: %v (提升 %.2fx)\n", pooledSimpleTime, 
        float64(simpleTime)/float64(pooledSimpleTime))
    fmt.Printf("池化复杂错误: %v (提升 %.2fx)\n", pooledComplexTime,
        float64(complexTime)/float64(pooledComplexTime))
    
    // 测试5: 错误字符串格式化性能
    demonstrateErrorFormattingPerformance()
}

func demonstrateErrorFormattingPerformance() {
    fmt.Println("\n=== 错误格式化性能 ===")
    
    const iterations = 100000
    
    // 测试1: 简单字符串连接
    start := time.Now()
    for i := 0; i < iterations; i++ {
        _ = "error: " + strconv.Itoa(i)
    }
    stringConcatTime := time.Since(start)
    
    // 测试2: fmt.Sprintf
    start = time.Now()
    for i := 0; i < iterations; i++ {
        _ = fmt.Sprintf("error: %d", i)
    }
    sprintfTime := time.Since(start)
    
    // 测试3: strings.Builder
    start = time.Now()
    for i := 0; i < iterations; i++ {
        var builder strings.Builder
        builder.WriteString("error: ")
        builder.WriteString(strconv.Itoa(i))
        _ = builder.String()
    }
    builderTime := time.Since(start)
    
    // 测试4: 预分配的strings.Builder
    start = time.Now()
    var builder strings.Builder
    for i := 0; i < iterations; i++ {
        builder.Reset()
        builder.WriteString("error: ")
        builder.WriteString(strconv.Itoa(i))
        _ = builder.String()
    }
    reuseBuilderTime := time.Since(start)
    
    fmt.Printf("字符串连接: %v\n", stringConcatTime)
    fmt.Printf("fmt.Sprintf: %v\n", sprintfTime)
    fmt.Printf("strings.Builder: %v\n", builderTime)
    fmt.Printf("复用Builder: %v\n", reuseBuilderTime)
    
    fmt.Printf("最快方法相对于fmt.Sprintf的提升: %.2fx\n",
        float64(sprintfTime)/float64(stringConcatTime))
}

:::

🎯 核心知识点总结

自定义错误基础要点

error接口: 只需实现Error() string方法
结构体错误: 可以包含更多上下文信息
工厂函数: 提供便捷的错误创建方法
方法链: 支持流畅的错误构建API

错误包装要点

Unwrap方法: 实现错误包装支持
errors.Is: 检查错误链中的特定错误
errors.As: 获取错误链中的特定类型
上下文信息: 在包装时添加有用的上下文

哨兵错误要点

全局变量: 定义为包级别的全局变量
预定义值: 表示特定的错误条件
标准库模式: io.EOF等是经典例子
比较方式: 使用errors.Is进行比较

性能优化要点

对象池化: 减少频繁的内存分配
格式化优化: 选择合适的字符串构建方法
避免复杂结构: 在高频场景下使用简单错误类型
基准测试: 测试不同实现的性能差异

🔍 面试准备建议

理解设计原则: 掌握何时使用自定义错误类型vs标准错误
熟悉包装机制: 深入理解Go 1.13+的错误包装特性
掌握哨兵模式: 了解哨兵错误的使用场景和最佳实践
性能意识: 了解错误处理对性能的影响和优化方法
实际应用: 能够设计适合具体业务场景的错误类型体系

自定义错误类型详解 - Golang基础面试题 ​

📋 重点面试题 ​

面试题 1：自定义错误类型的基本实现 ​

问题分析 ​

详细解答 ​

1. 简单自定义错误类型 ​

3. 错误工厂函数 ​

面试题 2：错误链和错误包装 ​

问题分析 ​

详细解答 ​

1. 支持错误包装的自定义错误 ​

2. 自定义错误链遍历 ​

面试题 3：哨兵错误和错误常量 ​

问题分析 ​

详细解答 ​

1. 哨兵错误的定义和使用 ​

2. 结合哨兵错误和自定义错误 ​

面试题 4：错误处理的性能优化 ​

问题分析 ​

详细解答 ​

1. 错误性能测试和优化 ​

🎯 核心知识点总结 ​

自定义错误基础要点 ​

错误包装要点 ​

哨兵错误要点 ​

性能优化要点 ​

🔍 面试准备建议 ​

自定义错误类型详解 - Golang基础面试题

📋 重点面试题

面试题 1：自定义错误类型的基本实现

问题分析

详细解答

1. 简单自定义错误类型

3. 错误工厂函数

面试题 2：错误链和错误包装

问题分析

详细解答

1. 支持错误包装的自定义错误

2. 自定义错误链遍历

面试题 3：哨兵错误和错误常量

问题分析

详细解答

1. 哨兵错误的定义和使用

2. 结合哨兵错误和自定义错误

面试题 4：错误处理的性能优化

问题分析

详细解答

1. 错误性能测试和优化

🎯 核心知识点总结

自定义错误基础要点

错误包装要点

哨兵错误要点

性能优化要点

🔍 面试准备建议