面试题：Go语言类型断言错误处理的性能优化与设计

设计思路

使用类型断言缓存：通过提前缓存类型断言的结果，避免在高并发场景下每次都进行类型断言操作，以此减少性能损耗。
错误处理优化：在缓存类型断言结果时，一并缓存断言错误的情况，确保每次获取断言结果时能快速得知是否断言成功，保证错误处理的正确性。

代码实现示例

package main

import (
    "fmt"
    "sync"
)

// TypeAssertCache 用于缓存类型断言结果
type TypeAssertCache struct {
    cache map[interface{}]interface{}
    errCache map[interface{}]error
    mu sync.RWMutex
}

// NewTypeAssertCache 创建新的类型断言缓存实例
func NewTypeAssertCache() *TypeAssertCache {
    return &TypeAssertCache{
        cache: make(map[interface{}]interface{}),
        errCache: make(map[interface{}]error),
    }
}

// Assert 进行类型断言并缓存结果
func (c *TypeAssertCache) Assert(i interface{}, target interface{}) (interface{}, error) {
    c.mu.RLock()
    if v, ok := c.cache[i]; ok {
        err := c.errCache[i]
        c.mu.RUnlock()
        return v, err
    }
    c.mu.RUnlock()

    var result interface{}
    var err error
    switch target := target.(type) {
    case *int:
        var ok bool
        result, ok = i.(int)
        if!ok {
            err = fmt.Errorf("type assertion failed for int")
        }
    case *string:
        var ok bool
        result, ok = i.(string)
        if!ok {
            err = fmt.Errorf("type assertion failed for string")
        }
    // 可根据实际需要添加更多类型断言分支
    }

    c.mu.Lock()
    c.cache[i] = result
    c.errCache[i] = err
    c.mu.Unlock()

    return result, err
}

func main() {
    cache := NewTypeAssertCache()
    var wg sync.WaitGroup

    var data []interface{}
    data = append(data, 10, "hello")

    for _, d := range data {
        wg.Add(1)
        go func(i interface{}) {
            defer wg.Done()
            result, err := cache.Assert(i, &int{})
            if err == nil {
                fmt.Printf("Type assertion success: %v\n", result)
            } else {
                fmt.Printf("Type assertion error: %v\n", err)
            }
        }(d)
    }

    wg.Wait()
}

在上述代码中：

TypeAssertCache 结构体包含两个映射，cache 用于缓存类型断言的结果，errCache 用于缓存断言错误。mu 是读写锁，用于保护缓存数据的并发访问。
NewTypeAssertCache 函数用于创建 TypeAssertCache 的实例。
Assert 方法首先尝试从缓存中获取类型断言的结果，如果缓存中没有，则进行类型断言操作，并将结果和错误信息缓存起来。
在 main 函数中，模拟了高并发场景下对不同类型数据进行类型断言的过程，通过 TypeAssertCache 减少重复断言带来的性能损耗，同时保证了错误处理的正确性。

星途面试题库

面试题：Go语言类型断言错误处理的性能优化与设计

知识考点

面试题答案

设计思路

代码实现示例