Golang中如何查找多个子字符串的索引：strings.Index用法

Golang中如何查找多个子字符串的索引：strings.Index用法 我想回答以下问题：

  • 在我的大字符串中，子字符串 A 位于哪个索引位置（如果存在的话）？
  • 在我的大字符串中，子字符串 B 位于哪个索引位置（如果存在的话）？ …
  • 在我的大字符串中，子字符串 X 位于哪个索引位置（如果存在的话）？

我可以为每个子字符串调用 strings.Index。但是否有更好的方法呢？我的意思是，能否调整 Knuth-Morris-Pratt 或 Boyer-Moore 算法，使它们能更高效地同时搜索多个子字符串？

是否已经有人实现了这一点？有没有现成的库？这里有人遇到过这个问题吗？


更多关于Golang中如何查找多个子字符串的索引：strings.Index用法的实战教程也可以访问 https://www.itying.com/category-94-b0.html

2 回复

Aho-Corasick algorithm

你找到它的 Go 实现了吗？

更多关于Golang中如何查找多个子字符串的索引：strings.Index用法的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，标准库的strings.Index函数确实只能查找单个子字符串的索引。对于需要同时查找多个子字符串的场景，目前标准库没有提供内置的多模式匹配函数。不过，你可以通过以下几种方式来实现：

1. 使用strings.Index循环查找（简单直接）

如果子字符串数量不多，直接循环调用strings.Index是最简单的方法：

package main

import (
    "fmt"
    "strings"
)

func findMultipleIndexes(str string, substrings []string) map[string]int {
    result := make(map[string]int)
    for _, sub := range substrings {
        if idx := strings.Index(str, sub); idx != -1 {
            result[sub] = idx
        }
    }
    return result
}

func main() {
    str := "Hello, welcome to Golang programming world!"
    substrings := []string{"welcome", "Golang", "world", "Python"}
    
    indexes := findMultipleIndexes(str, substrings)
    for sub, idx := range indexes {
        fmt.Printf("子字符串 '%s' 的索引位置: %d\n", sub, idx)
    }
}

2. 使用正则表达式（适合模式匹配）

如果子字符串是固定的文本模式，可以使用正则表达式：

package main

import (
    "fmt"
    "regexp"
)

func findWithRegex(str string, patterns []string) map[string]int {
    result := make(map[string]int)
    for _, pattern := range patterns {
        re := regexp.MustCompile(regexp.QuoteMeta(pattern))
        loc := re.FindStringIndex(str)
        if loc != nil {
            result[pattern] = loc[0]
        }
    }
    return result
}

func main() {
    str := "Go is fast, Go is simple, Go is fun"
    patterns := []string{"fast", "simple", "fun", "complex"}
    
    indexes := findWithRegex(str, patterns)
    for pattern, idx := range indexes {
        fmt.Printf("模式 '%s' 的索引位置: %d\n", pattern, idx)
    }
}

3. 使用第三方库（高效多模式匹配）

对于需要高性能的多模式匹配，可以考虑使用第三方库。以下是使用ahocorasick库的示例：

首先安装库：

go get github.com/cloudflare/ahocorasick

然后使用：

package main

import (
    "fmt"
    "github.com/cloudflare/ahocorasick"
)

func main() {
    str := "The quick brown fox jumps over the lazy dog"
    substrings := []string{"quick", "fox", "dog", "cat"}
    
    // 创建AC自动机
    builder := ahocorasick.NewAhoCorasickBuilder(ahocorasick.Opts{
        AsciiCaseInsensitive: false,
        MatchOnlyWholeWords:  false,
        MatchKind:            ahocorasick.StandardMatch,
        DFA:                  true,
    })
    
    ac := builder.Build(substrings)
    
    // 执行匹配
    matches := ac.FindAll(str)
    
    // 输出结果
    for _, match := range matches {
        fmt.Printf("子字符串 '%s' 的索引位置: %d\n", 
            substrings[match.Pattern()], match.Pos())
    }
}

4. 使用strings.IndexAny查找字符集

如果只需要查找一组字符中的任意一个，可以使用strings.IndexAny：

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Golang programming 2024"
    chars := "aeiou"
    
    idx := strings.IndexAny(str, chars)
    if idx != -1 {
        fmt.Printf("第一个元音字母 '%c' 出现在索引位置: %d\n", str[idx], idx)
    }
}

性能比较

  • 少量子字符串：使用strings.Index循环足够高效
  • 大量子字符串：推荐使用Aho-Corasick算法（如ahocorasick库）
  • 模式匹配：使用正则表达式更灵活
  • 字符集查找：strings.IndexAny最合适

对于大多数应用场景，循环调用strings.Index已经足够。只有在需要匹配大量模式（数百或数千个）时，才需要考虑使用专门的算法库。

回到顶部