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

下载万磁搜索绿色版

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

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

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

解决方案

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

1. 数据准备： 假设我们有一批文本文件，每个文件代表一个文档。

2. 分词： 使用 Go 的 strings.Fields 函数或其他分词库（例如 github.com/go-ego/gse，如果你需要更高级的分词功能，比如支持中文）将每个文档分割成词语。

3. 构建索引： 创建一个 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)
}

接下来，实现查询功能。

1. 解析查询： 将用户的查询语句分割成词语。

2. 检索： 在倒排索引中查找每个词语对应的文档 ID 列表。

3. 合并结果： 将所有词语的文档 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)
}

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

1. 计算相关性： 对于每个匹配的文档，计算它包含查询词语的数量。

2. 排序： 根据相关性对文档进行排序。

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)
}

如何优化Go语言搜索引擎的性能？

性能优化可以从多方面入手。一方面是索引构建速度，可以考虑并行构建索引，使用 Goroutines 并发处理不同的文档。另一方面是查询速度，可以使用更高效的数据结构来存储索引，例如使用 Trie 树。 另外，缓存热点查询结果也能显著提升性能。 还有就是使用更高级的排序算法，例如 BM25。

Go语言搜索引擎如何处理中文分词？

处理中文分词是个挑战，因为中文没有空格来分隔词语。 可以使用专门的中文分词库，例如 github.com/go-ego/gse。 这个库提供了多种分词算法，可以根据你的需求选择。 使用时，先初始化分词器，然后将文本传递给分词器进行分词。

如何扩展Go语言搜索引擎的功能？

可以考虑添加以下功能：

• 支持更多文件格式： 目前只支持文本文件，可以扩展到支持 PDF、HTML 等格式。
• 支持布尔查询： 支持 AND、OR、NOT 等布尔运算符。
• 支持模糊查询： 允许用户输入拼写错误的词语。
• 支持权重： 允许用户为不同的词语设置权重，影响排序结果。
• Web 界面： 提供一个 Web 界面，方便用户使用。
• 分布式搜索： 将索引和查询分布到多台机器上，提高性能和可扩展性。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~