当前位置：首页 > 文章列表 > Golang > Go教程 > 手把手教你用Go语言撸一个简易搜索引擎（附详细代码）

手把手教你用Go语言撸一个简易搜索引擎（附详细代码）

2025-06-19 08:32:37 0浏览收藏

想知道如何用Go语言打造一个简易搜索引擎吗？本文将手把手教你从零开始，理解信息检索的核心原理，并用Go语言代码实现。文章深入讲解了倒排索引的构建、查询功能的实现以及排序算法的应用，为你构建搜索引擎打下坚实基础。通过本文，你将学会如何使用Go语言的`strings.Fields`函数进行分词，构建`map[string][]int`倒排索引，以及实现OR查询。此外，还介绍了性能优化的技巧，例如并行索引构建、高效数据结构和BM25排序算法，以及如何使用`gse`库进行中文分词。最后，还探讨了如何扩展搜索引擎的功能，包括支持多种文件格式、布尔查询、模糊查询、权重设置、Web界面和分布式搜索，助你打造更强大的搜索引擎。

构建简单搜索引擎需理解信息检索原理并实现索引构建、查询处理和排序算法。1. 构建倒排索引：将文档分词后用 map 存储词语到文档ID的映射；2. 实现查询功能：解析查询词语，从索引中检索并合并结果（如OR查询）；3. 排序功能：根据文档匹配词语数量排序。性能优化包括并行索引构建、高效数据结构、缓存及高级排序算法BM25。中文分词可使用 gse 库。扩展功能包括支持多种文件格式、布尔查询、模糊查询、权重设置、Web界面和分布式搜索。

入门教程：使用Go语言实现简单搜索引擎

构建一个简单的搜索引擎，核心在于理解信息检索的基本原理并在代码中实现它们。这不仅仅是调用几个库，而是深入了解索引构建、查询处理和排序算法。

解决方案

首先，我们需要构建一个倒排索引。这就像一本书的索引，但不是从主题到页码，而是从词语到包含这些词语的文档。

数据准备： 假设我们有一批文本文件，每个文件代表一个文档。
分词： 使用 Go 的 strings.Fields 函数或其他分词库（例如 github.com/go-ego/gse，如果你需要更高级的分词功能，比如支持中文）将每个文档分割成词语。
构建索引： 创建一个 map[string][]int 来存储倒排索引。键是词语，值是包含该词语的文档 ID 列表。

package main

import (
    "fmt"
    "strings"
)

func buildIndex(documents []string) map[string][]int {
    index := make(map[string][]int)
    for docID, doc := range documents {
        words := strings.Fields(doc)
        for _, word := range words {
            if _, ok := index[word]; !ok {
                index[word] = []int{}
            }
            index[word] = append(index[word], docID)
        }
    }
    return index
}

func main() {
    documents := []string{
        "the quick brown fox jumps over the lazy dog",
        "the brown fox is quick",
        "the dog is lazy",
    }

    index := buildIndex(documents)
    fmt.Println(index)
}

接下来，实现查询功能。

解析查询： 将用户的查询语句分割成词语。
检索： 在倒排索引中查找每个词语对应的文档 ID 列表。
合并结果： 将所有词语的文档 ID 列表合并，可以使用交集（AND 查询）或并集（OR 查询）。简单起见，我们实现一个 OR 查询。

package main

import (
    "fmt"
    "strings"
)

func buildIndex(documents []string) map[string][]int {
    index := make(map[string][]int)
    for docID, doc := range documents {
        words := strings.Fields(doc)
        for _, word := range words {
            if _, ok := index[word]; !ok {
                index[word] = []int{}
            }
            index[word] = append(index[word], docID)
        }
    }
    return index
}

func search(index map[string][]int, query string) []int {
    queryWords := strings.Fields(query)
    results := make(map[int]bool)
    for _, word := range queryWords {
        if docIDs, ok := index[word]; ok {
            for _, docID := range docIDs {
                results[docID] = true
            }
        }
    }

    var resultList []int
    for docID := range results {
        resultList = append(resultList, docID)
    }
    return resultList
}

func main() {
    documents := []string{
        "the quick brown fox jumps over the lazy dog",
        "the brown fox is quick",
        "the dog is lazy",
    }

    index := buildIndex(documents)
    query := "quick lazy"
    results := search(index, query)

    fmt.Printf("Search results for '%s': %v\n", query, results)
}

最后，实现排序功能。简单起见，我们根据文档包含查询词语的数量进行排序。

计算相关性： 对于每个匹配的文档，计算它包含查询词语的数量。
排序： 根据相关性对文档进行排序。

package main

import (
    "fmt"
    "sort"
    "strings"
)

func buildIndex(documents []string) map[string][]int {
    index := make(map[string][]int)
    for docID, doc := range documents {
        words := strings.Fields(doc)
        for _, word := range words {
            if _, ok := index[word]; !ok {
                index[word] = []int{}
            }
            index[word] = append(index[word], docID)
        }
    }
    return index
}

func search(index map[string][]int, query string) map[int]int {
    queryWords := strings.Fields(query)
    results := make(map[int]int) // docID -> count
    for _, word := range queryWords {
        if docIDs, ok := index[word]; ok {
            for _, docID := range docIDs {
                results[docID]++
            }
        }
    }
    return results
}

func sortResults(results map[int]int) []int {
    type kv struct {
        Key   int
        Value int
    }

    var ss []kv
    for k, v := range results {
        ss = append(ss, kv{k, v})
    }

    sort.Slice(ss, func(i, j int) bool {
        return ss[i].Value > ss[j].Value // Descending order
    })

    var sortedDocIDs []int
    for _, kv := range ss {
        sortedDocIDs = append(sortedDocIDs, kv.Key)
    }
    return sortedDocIDs
}

func main() {
    documents := []string{
        "the quick brown fox jumps over the lazy dog",
        "the brown fox is quick",
        "the dog is lazy and quick",
    }

    index := buildIndex(documents)
    query := "quick lazy"
    results := search(index, query)
    sortedResults := sortResults(results)

    fmt.Printf("Search results for '%s': %v\n", query, sortedResults)
}