Go语言中如何正确访问接口类型（interface{}）持有的结构体字段

package search

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io/ioutil" // 假设body是从请求中读取的
)

// SearchItemsByUser 函数解码JSON数据并返回interface{}
func SearchItemsByUser(r *http.Request) interface{} {
    // results 结构体定义在函数内部，是私有的
    type results struct {
        Hits             interface{} `json:"hits"` // 示例中未给出详细类型，这里使用interface{}
        NbHits           int         `json:"nbHits"`
        NbPages          int         `json:"nbPages"`
        HitsPerPage      int         `json:"hitsPerPage"`
        ProcessingTimeMS int         `json:"processingTimeMS"`
        Query            string      `json:"query"`
        Params           string      `json:"params"`
    }

    var Result results

    // 模拟从请求体读取JSON
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        fmt.Println("Error reading body:", err)
        return nil
    }

    er := json.Unmarshal(body, &Result)
    if er != nil {
        fmt.Println("Error unmarshalling JSON:", er)
        return nil
    }
    return Result
}

// test 函数尝试访问返回的interface{}字段
func test(w http.ResponseWriter, r *http.Request) {
    result := SearchItemsByUser(r)
    // 错误示例：直接访问 interface{} 的字段
    // fmt.Fprintf(w, "Params: %s", result.Params) // 编译错误：result.Params undefined (type interface {} has no field or method Params)
    fmt.Fprintf(w, "尝试直接访问字段会导致编译错误。\n")
}

dynamic_value := interface_variable.(typename)

dynamic_value, ok := interface_variable.(typename)
if !ok {
    // 类型断言失败，处理错误
    fmt.Println("类型断言失败，interface_variable 不是 typename 类型")
    return
}
// 成功断言，现在可以访问 dynamic_value 的字段了

// 假设 results 结构体是可访问的，例如定义在包级别
// type results struct { ... }

func testWithAssertion(w http.ResponseWriter, r *http.Request) {
    result := SearchItemsByUser(r)

    // 尝试类型断言
    // 注意：这里的 search.results 假设 results 结构体是公开的，并且定义在 search 包中
    // 但在原始问题中，results 是私有且局部的，因此这种断言会失败或无法编译
    concreteResult, ok := result.(search.results) // 如果 results 是私有的，这里会是编译错误
    if !ok {
        fmt.Fprintf(w, "错误：返回的接口值不是 search.results 类型。\n")
        return
    }
    fmt.Fprintf(w, "通过类型断言访问 Params: %s\n", concreteResult.Params)
}

package search

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

// Results 结构体定义在包级别，并导出（首字母大写）
// 这样在其他包中也能引用这个类型
type Results struct {
    Hits             interface{} `json:"hits"`
    NbHits           int         `json:"nbHits"`
    NbPages          int         `json:"nbPages"`
    HitsPerPage      int         `json:"hitsPerPage"`
    ProcessingTimeMS int         `json:"processingTimeMS"`
    Query            string      `json:"query"`
    Params           string      `json:"params"`
}

// SearchItemsByUser 函数现在直接返回 Results 类型
func SearchItemsByUser(r *http.Request) (*Results, error) { // 返回指针和错误，更符合Go习惯
    var result Results

    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading request body: %w", err)
    }

    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("error unmarshalling JSON: %w", err)
    }
    return &result, nil
}

package main

import (
    "fmt"
    "net/http"
    "github.com/yourproject/search" // 假设你的search包路径
)

func main() {
    http.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
        // 调用 SearchItemsByUser，直接得到具体类型 *search.Results
        result, err := search.SearchItemsByUser(r)
        if err != nil {
            http.Error(w, fmt.Sprintf("Error searching items: %v", err), http.StatusInternalServerError)
            return
        }

        // 现在可以直接访问字段，无需类型断言
        fmt.Fprintf(w, "Params: %s\n", result.Params)
        fmt.Fprintf(w, "NbHits: %d\n", result.NbHits)
        // 更多的字段访问...
    })

    fmt.Println("Server listening on :8080")
    http.ListenAndServe(":8080", nil)
}