深入理解Go语言中map类型与struct的性能考量及最佳实践

package main

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

// 模拟一个处理参数的函数
func processArgsStringMap(args map[string]string) {
    urlCountStr, ok := args["url_count"]
    if !ok {
        fmt.Println("url_count not found")
        return
    }
    urlCount, err := strconv.Atoi(urlCountStr)
    if err != nil {
        fmt.Printf("Error converting url_count: %v\n", err)
        return
    }

    // 模拟一些操作
    time.Sleep(1 * time.Millisecond) // 模拟耗时操作

    successCount := urlCount / 2 // 假设一半成功
    args["success_url_count"] = strconv.Itoa(successCount)
}

func main() {
    // 模拟使用 map[string]string
    argsString := make(map[string]string)
    argsString["url_count"] = "100"

    start := time.Now()
    for i := 0; i < 1000; i++ { // 循环多次模拟频繁调用
        processArgsStringMap(argsString)
    }
    fmt.Printf("map[string]string 耗时: %v\n", time.Since(start))
}

package main

import (
    "fmt"
    "time"
)

// 模拟一个处理参数的函数
func processArgsInterfaceMap(args map[string]interface{}) {
    urlCountVal, ok := args["url_count"]
    if !ok {
        fmt.Println("url_count not found")
        return
    }
    // 需要进行类型断言
    urlCount, ok := urlCountVal.(int)
    if !ok {
        fmt.Printf("Error: url_count is not an int, got %T\n", urlCountVal)
        return
    }

    // 模拟一些操作
    time.Sleep(1 * time.Millisecond) // 模拟耗时操作

    successCount := urlCount / 2
    args["success_url_count"] = successCount // 直接存储int类型
}

func main() {
    // 模拟使用 map[string]interface{}
    argsInterface := make(map[string]interface{})
    argsInterface["url_count"] = 100 // 直接存储int类型

    start := time.Now()
    for i := 0; i < 1000; i++ { // 循环多次模拟频繁调用
        processArgsInterfaceMap(argsInterface)
    }
    fmt.Printf("map[string]interface{} 耗时: %v\n", time.Since(start))
}

package main

import (
    "fmt"
    "time"
)

// 定义一个结构体来封装参数
type FetcherArgs struct {
    UrlCount      int
    SuccessUrlCount int
    // ... 其他参数，例如 FooBar string
}

// 模拟一个处理参数的函数，接收结构体指针
func processArgsStruct(args *FetcherArgs) {
    // 直接访问结构体字段，无需类型断言或转换
    urlCount := args.UrlCount

    // 模拟一些操作
    time.Sleep(1 * time.Millisecond) // 模拟耗时操作

    args.SuccessUrlCount = urlCount / 2 // 直接修改结构体字段
}

func main() {
    // 模拟使用 struct
    argsStruct := &FetcherArgs{
        UrlCount: 100,
    }

    start := time.Now()
    for i := 0; i < 1000; i++ { // 循环多次模拟频繁调用
        processArgsStruct(argsStruct)
    }
    fmt.Printf("struct 耗时: %v\n", time.Since(start))
    fmt.Printf("最终成功URL数量: %d\n", argsStruct.SuccessUrlCount)
}