Golang 编译错误: opts.Results 未定义，如何解决？

在 Golang 开发中，你可能遇到过这样的编译错误：opts.Results undefined (type options has no field or method Results)。这通常表示你的 options 结构体中缺少名为 Results 的字段或方法。

错误原因：

编译器无法找到 options 结构体中名为 Results 的字段或方法，因此无法使用它。

解决方法：

你需要在 options 结构体中定义 Results 字段，并将其类型设置为所需类型。

示例代码：

package main

import (
    "bufio"
    "flag"
    "fmt"
    "os"
    "strconv"
    "strings"
    "sync"

    "github.com/logrusorgru/aurora/v3"
    log "github.com/projectdiscovery/gologger"
    "github.com/projectdiscovery/gologger/levels"
)

var (
    query      string
    engine     string
    page       int
    headers    headersFlag
    proxy      string
    silent     bool
    queries    []string
    wg         sync.WaitGroup
    outputFile string
)

type options struct {
    Query   string
    Engine  string
    Page    int
    Proxy   string
    Headers headersFlag
    Results []string // 添加 Results 字段
}

func (o *options) search() (bool, error) {
    switch o.Engine {
    case "google":
        return googleSearch(o)
    case "shodan":
        return shodanSearch(o)
    case "bing":
        return bingSearch(o)
    case "duck":
        return duckSearch(o)
    case "yahoo":
        return yahooSearch(o)
    case "ask":
        return askSearch(o)
    default:
        return false, fmt.Errorf("invalid engine")
    }
}

func init() {
    flag.StringVar(&query, "q", "", "")
    flag.StringVar(&query, "query", "", "")

    flag.StringVar(&engine, "e", "", "")
    flag.StringVar(&engine, "engine", "google", "")

    flag.IntVar(&page, "p", 1, "")
    flag.IntVar(&page, "page", 1, "")

    flag.Var(&headers, "header", "")
    flag.Var(&headers, "H", "")

    flag.StringVar(&proxy, "x", "", "")
    flag.StringVar(&proxy, "proxy", "", "")

    flag.BoolVar(&silent, "s", false, "")
    flag.BoolVar(&silent, "silent", false, "")

    flag.StringVar(&outputFile, "o", "", "")
    flag.StringVar(&outputFile, "output", "", "")

    flag.Usage = func() {
        h := []string{
            "Options:",
            "  -q, --query <query>          Search query",
            "  -e, --engine <engine>        Provide search engine (default: Google)",
            "                               (options: Google, Shodan, Bing, Duck, Yahoo, Ask)",
            "  -p, --page <i>               Specify number of pages (default: 1)",
            "  -H, --header <header>        Pass custom header to search engine",
            "  -x, --proxy <proxy_url>      Use proxy to surfing (HTTP/SOCKSv5 proxy)",
            "  -s, --silent                 Silent mode",
            "  -o, --output <output_file>   Output search result to file",
            "\n",
        }
        showBanner()
        fmt.Fprintf(os.Stderr, "%s", aurora.Green(strings.Join(h, "\n")))
    }
    flag.Parse()

    engine = strings.ToLower(engine)

    maxLog := levels.LevelDebug
    if silent {
        maxLog = levels.LevelSilent
    }
    log.DefaultLogger.SetMaxLevel(maxLog)

    showBanner()
}

func main() {
    if isStdin() {
        sc := bufio.NewScanner(os.Stdin)
        for sc.Scan() {
            q := sc.Text()
            queries = append(queries, q)
        }
    } else {
        if query == "" {
            log.Fatal().Msgf("Missing required -q flag!")
            os.Exit(2)
        }

        queries = []string{query}
    }

    log.Info().Msgf("Query : %+v", queries)
    log.Info().Msgf("Page  : %s", strconv.Itoa(page))
    if proxy != "" {
        log.Info().Msgf("Proxy : %s", proxy)
    }
    if len(headers) > 0 {
        log.Info().Msgf("Header: [%+v]", headers)
    }
    log.Info().Msgf("Engine: %s", strings.Title(engine))
    log.Warning().Msg("Use at your own risk! Developers assume no responsibility...")
    log.Warning().Msg("If your IP address has been blocked by search engine providers or other reason.\n\n")

    for _, q := range queries {
        wg.Add(1)
        go func(dork string) {
            defer wg.Done()
            opts := options{
                Query:   dork,
                Engine:  engine,
                Page:    page,
                Proxy:   proxy,
                Headers: headers,
            }

            fatal, err := opts.search()
            if err != nil {
                if fatal {
                    isError(err)
                }
                log.Warning().Msgf("Something error %s.", err.Error())
            }

            if outputFile != "" {
                writeToFile(opts.Results, outputFile)
            }
        }(q)
    }
    wg.Wait()
}

func writeToFile(content []string, filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }

    defer file.Close()

    for _, line := range content {
        _, err := file.WriteString(line + "\n")
        if err != nil {
            return err
        }
    }

    return nil
}

解释：

在 options 结构体中添加了 Results 字段，类型为 []string。
Results 字段将用来存储搜索结果。
在 search() 函数中，你需要将搜索结果存储到 o.Results 字段中。
在 main() 函数中，你可以使用 opts.Results 访问搜索结果。

通过这些步骤，你就可以解决 “opts.Results undefined” 错误，并使用 options 结构体存储搜索结果。