Go语言类型转换指南：解决布尔值到字符串的类型不匹配错误

response2, err := core.SearchRequest(true, "people", "male", searchQuery, "")

response2, err := core.SearchRequest("true", "people", "male", searchQuery, "")

var isAllowed bool = true
stringRepresentation := fmt.Sprintf("%t", isAllowed) // stringRepresentation 将是 "true"

// 假设我们需要将 'true' 转换为字符串 "true"
// 如果 SearchRequest 的第一个参数需要一个表示布尔状态的字符串
response2, err := core.SearchRequest(fmt.Sprintf("%t", true), "people", "male", searchQuery, "")

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    // 假设 api 和 core 包已定义
    // type API struct { Domain string }
    // var api API
    // type Core struct {}
    // func (c *Core) SearchRequest(param1 string, index string, docType string, query string, routing string) (map[string]interface{}, error) {
    //  // 模拟搜索请求
    //  if param1 != "true" {
    //      return nil, fmt.Errorf("expected 'true' for param1")
    //  }
    //  return map[string]interface{}{
    //      "Hits": map[string]interface{}{
    //          "Hits": []interface{}{
    //              map[string]interface{}{"Source": []byte(`{"name":"John Doe","gender":"male"}`)},
    //              map[string]interface{}{"Source": []byte(`{"name":"Jane Doe","gender":"female"}`)},
    //          },
    //      },
    //  }, nil
    // }
    // var core Core
)

// 模拟 core 包的结构以使示例代码可运行
type MockCore struct{}

func (c *MockCore) SearchRequest(param1 string, index string, docType string, query string, routing string) (map[string]interface{}, error) {
    if param1 != "true" {
        return nil, fmt.Errorf("expected 'true' for param1, got %s", param1)
    }
    // 模拟Elasticsearch的响应结构
    return map[string]interface{}{
        "Hits": map[string]interface{}{
            "Hits": []map[string]interface{}{
                {"Source": []byte(`{"name":"Alice","gender":"male"}`)},
                {"Source": []byte(`{"name":"Bob","gender":"male"}`)},
            },
        },
    }, nil
}

// 模拟 api 包的结构
type MockAPI struct {
    Domain string
}

var api MockAPI
var core MockCore // 使用模拟的 core 实例

func SearchCallback(w http.ResponseWriter, req *http.Request) {

    api.Domain = "127.0.0.1"

    // search males
    searchQuery := `{
        "query": {
            "term": {"content":"male"}
        }
    }`
    var response2 map[string]interface{}
    var err error

    // 修正：将 'true' 替换为字符串 "true"
    // 或者使用 fmt.Sprintf("%t", true)
    response2, err = core.SearchRequest("true", "people", "male", searchQuery, "") // 方案一：直接使用字符串字面量
    // response2, err = core.SearchRequest(fmt.Sprintf("%t", true), "people", "male", searchQuery, "") // 方案二：使用 fmt.Sprintf

    if err != nil {
        log.Fatalf("The search of males has failed: %v", err) // 改进错误日志格式
    }

    // 模拟 Elasticsearch 响应的结构，以便正确解析
    // 实际情况中，response2 可能需要更复杂的类型断言或定义结构体来解析
    hitsData, ok := response2["Hits"].(map[string]interface{})
    if !ok {
        log.Fatalf("Failed to get 'Hits' from response")
    }
    innerHits, ok := hitsData["Hits"].([]map[string]interface{}) // 假设内部 Hits 是 []map[string]interface{}
    if !ok {
        log.Fatalf("Failed to get inner 'Hits' from response")
    }

    var values2 []interface{}
    for _, v := range innerHits {
        sourceBytes, ok := v["Source"].([]byte)
        if !ok {
            log.Fatalf("Failed to get 'Source' bytes from hit")
        }

        var value2 map[string]interface{}
        err := json.Unmarshal(sourceBytes, &value2)
        if err != nil {
            log.Fatalf("Failed to unmarshal source: %v", err)
        }
        values2 = append(values2, value2)
    }
    fmt.Println("Extracted values:", values2)

    jsonV2, err := json.Marshal(values2)
    if err != nil {
        log.Fatalf("Failed marshalling values: %v", err)
    }
    fmt.Println("Marshalled JSON:", string(jsonV2))

    // 在实际的HTTP处理函数中，应该将结果写入w
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(jsonV2)
}

func main() {
    // 模拟一个 HTTP 请求来测试 SearchCallback
    req, _ := http.NewRequest("GET", "/", nil)
    rr := &MockResponseWriter{} // 自定义一个ResponseWriter
    SearchCallback(rr, req)
}

// MockResponseWriter 模拟 http.ResponseWriter
type MockResponseWriter struct {
    HeaderMap http.Header
    Body      []byte
    Status    int
}

func (m *MockResponseWriter) Header() http.Header {
    if m.HeaderMap == nil {
        m.HeaderMap = make(http.Header)
    }
    return m.HeaderMap
}

func (m *MockResponseWriter) Write(data []byte) (int, error) {
    m.Body = append(m.Body, data...)
    return len(data), nil
}

func (m *MockResponseWriter) WriteHeader(statusCode int) {
    m.Status = statusCode
}