使用前缀树实现敏感词过滤

走，我们去吹风

已于 2023-08-12 15:20:43 修改

阅读量437

点赞数 1

文章标签： java 算法数据结构 golang 后端

于 2023-08-12 15:16:28 首次发布

本文链接：https://blog.csdn.net/weixin_51991615/article/details/132249224

版权

在一些论坛或者博客类的项目需要对内容进行敏感词的匹配以及脱敏操作，像这类的功能就可以使用前缀树实现，接下来我们就使用哈希去实现前缀树。（gin框架的路由树也是基于前缀树实现的）

什么是前缀树？

前缀树（Prefix Tree），也被称为字典树（Trie），是一种用于高效存储和检索字符串的数据结构。它的主要特点是能够快速地查找具有相同前缀的字符串集合。

既然使用前缀树做字符匹配那么它有什么特点？

高效的字符串存储：前缀树使用共享前缀的方式存储字符串，因此可以高效地存储大量字符串集合。相同的前缀会被共享，减少了存储空间的需求。
快速的字符串搜索：前缀树可以快速地搜索具有相同前缀的字符串集合。通过从根节点开始，按照字符依次向下遍历树的路径，可以高效地定位到匹配的字符串。
前缀匹配：前缀树可以快速地找出与给定字符串具有相同前缀的所有字符串。通过遍历匹配到的子树，可以得到所有以给定前缀开头的字符串。
支持动态更新：前缀树可以动态地插入和删除字符串。当需要插入或删除一个字符串时，只需按照字符依次遍历树的路径，根据需要插入或删除节点。
适用于字符串相关操作：前缀树广泛应用于字符串相关的操作，如自动补全、拼写检查、词频统计、字符串搜索和匹配等。由于其高效的存储和检索特性，可以在这些场景下提供快速和高效的操作。
路径压缩：前缀树具有路径压缩的能力，可以减少不必要的节点，节省存储空间。当某个节点只有一个子节点时，可以将中间节点合并，减少冗余的节点。

实现思路

假设我们有以下敏感词列表：["bad", "evil", "danger"]

		(root)                    ["bad", "evil", "danger"]
        / | \
       b  e  d
      /   |   \
     a    v    a
    /     |     \
   d      i      n
          |       \
          l        g
          |         \
          e          e

在这个前缀树中，每个节点代表一个字符，根节点表示空字符，每个节点的子节点表示对应的字符。叶子节点表示一个完整的敏感词。

遍历实现思路：

遍历待检测的文本。
从根节点开始，按照文本中的字符依次遍历前缀树的路径。
如果在遍历过程中遇到空路径，或者遍历完成后当前节点不是叶子节点，则表示没有匹配到敏感词，继续遍历下一个字符。
如果遍历完成后当前节点是叶子节点，则表示匹配到了敏感词，根据需求进行相应的处理，如替换为星号或进行其他处理。

代码实现

package sensitiveWord

import (
	"io/ioutil"
	"os"
	"project/consts"
	"project/types"
	"strings"

	"go.uber.org/zap"
)

// SensitiveMap 使用前缀树实现敏感词过滤
type SensitiveMap struct {
	sensitiveNode map[string]interface{}
	isEnd         bool
}

// Target 目标词索引、长度
type Target struct {
	Indexes []int
	Len     int
}

var s *SensitiveMap

// getMap 将自己的词库放入/static/dictionary下，放入下列切片中！！！！
func getMap() *SensitiveMap {
	if s == nil {
		var Sen []string
		Sen = append(Sen, consts.OtherSen)
		s = InitDictionary(s, Sen)
	}

	return s
}

// CheckSensitiveWord 判断是否有敏感词
func CheckSensitiveWord(content string) []*types.SensitiveWord {
	var res []*types.SensitiveWord
	sensitiveMap := getMap()
	target := sensitiveMap.FindAllSensitive(content)
	for k, v := range target {
		t := &types.SensitiveWord{
			Word:    k,
			Indexes: v.Indexes,
			Length:  v.Len,
		}
		res = append(res, t)
	}

	return res
}

// FindAllSensitive 查找所有的敏感词
func (s *SensitiveMap) FindAllSensitive(text string) map[string]*Target {
	content := []rune(text)
	contentLength := len(content)
	result := false
	ta := make(map[string]*Target)

	for index := range content {
		sMapTmp := s
		target := ""
		in := index
		result = false

		for {
			wo := string(content[in])
			target += wo
			if _, ok := sMapTmp.sensitiveNode[wo]; ok {
				if sMapTmp.sensitiveNode[wo].(*SensitiveMap).isEnd {
					result = true
					break
				}
				if in == contentLength-1 {
					break
				}
				sMapTmp = sMapTmp.sensitiveNode[wo].(*SensitiveMap)
				in++
			} else {
				break
			}
		}
		if result {
			if _, targetInTa := ta[target]; targetInTa {
				ta[target].Indexes = append(ta[target].Indexes, index)
			} else {
				ta[target] = &Target{
					Indexes: []int{index},
					Len:     len([]rune(target)),
				}
			}
		}
	}

	return ta
}

// InitDictionary 初始化字典，构造前缀树
func InitDictionary(s *SensitiveMap, dictionary []string) *SensitiveMap {
	// 初始化字典树
	s = initSensitiveMap()
	var dictionaryContent []string
	for i := 0; i < len(dictionary); i++ {
		dictionaryContentTmp := ReadDictionary(dictionary[i])
		// TODO:将所有词拿到
		dictionaryContent = append(dictionaryContent, dictionaryContentTmp...)
	}
	for _, words := range dictionaryContent {
		sMapTmp := s
		// 将每一个词转换为一个rune数组，不光英文、中文
		w := []rune(words)
		wordsLen := len(w)
		for i := 0; i < wordsLen; i++ {
			t := string(w[i])
			isEnd := false
			if i == (wordsLen - 1) {
				isEnd = true
			}
			func(tx string) {
        // 查看当前字符在不在树结构，在的话就复用节点
				if _, ok := sMapTmp.sensitiveNode[tx]; !ok {
					sMapTemp := new(SensitiveMap)
					sMapTemp.sensitiveNode = make(map[string]interface{})
					sMapTemp.isEnd = isEnd
					sMapTmp.sensitiveNode[tx] = sMapTemp
				}
				sMapTmp = sMapTmp.sensitiveNode[tx].(*SensitiveMap)
				sMapTmp.isEnd = isEnd
			}(t)
		}
	}

	return s
}

// initSensitiveMap 初始化map
func initSensitiveMap() *SensitiveMap {
	return &SensitiveMap{
		sensitiveNode: make(map[string]interface{}),
		isEnd:         false,
	}
}

// ReadDictionary 将词库读取出来
func ReadDictionary(path string) []string {
	file, err := os.Open(path)
	if err != nil {
		zap.L().Error("read dictionary file failed:", zap.Error(err))
		return nil
	}

	defer file.Close()

	str, err := ioutil.ReadAll(file)
	dictionary := strings.Fields(string(str))

	return dictionary
}