敏感词过滤服务

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
	"strings"
	"sync"
)

// TrieNode  Trie树节点
type TrieNode struct {
	children map[rune]*TrieNode
	isEnd    bool
}

// Trie  Trie树
type Trie struct {
	root *TrieNode
	lock sync.RWMutex
}

// NewTrie  创建新的Trie树
func NewTrie() *Trie {
	return &Trie{
		root: &TrieNode{children: make(map[rune]*TrieNode)},
	}
}

// Insert  向Trie树中插入敏感词
func (t *Trie) Insert(word string) {
	t.lock.Lock()
	defer t.lock.Unlock()

	node := t.root
	for _, char := range word {
		if _, ok := node.children[char]; !ok {
			node.children[char] = &TrieNode{children: make(map[rune]*TrieNode)}
		}
		node = node.children[char]
	}
	node.isEnd = true
}

// Delete  从Trie树中删除敏感词
func (t *Trie) Delete(word string) {
	t.lock.Lock()
	defer t.lock.Unlock()

	node := t.root
	nodes := make([]*TrieNode, 0)
	chars := make([]rune, 0)
	for _, char := range word {
		if _, ok := node.children[char]; !ok {
			return // 如果没有找到，直接返回
		}
		nodes = append(nodes, node)
		chars = append(chars, char)
		node = node.children[char]
	}
	if !node.isEnd {
		return // 查找的不是一个词的结尾，不需要删除
	}

	if len(node.children) == 0 {
		for i := len(nodes) - 1; i >= 0; i-- {
			parentNode := nodes[i]
			delete(parentNode.children, chars[i])
			if len(parentNode.children) > 0 || parentNode == t.root {
				break
			}
		}
	} else {
		node.isEnd = false // 如果该节点还有子节点，仅取消isEnd
	}
}


// Contains  检查Trie树中是否存在敏感词
func (t *Trie) Contains(word string) bool {
    t.lock.RLock()
    defer t.lock.RUnlock()

    node := t.root
    for _, char := range word {
        if _, ok := node.children[char]; !ok {
            return false
        }
        node = node.children[char]
    }
    return node.isEnd
}


// Filter  过滤文本中的敏感词，并用替换符替换
func (t *Trie) Filter(text string, replaceRune rune) string {
	t.lock.RLock()
	defer t.lock.RUnlock()

    result := []rune(text)
    for i := 0; i < len(result); i++ {
        node := t.root
        start := i
        for j := i; j < len(result); j++ {
            char := result[j]
            if _, ok := node.children[char]; !ok {
                break
            }
            node = node.children[char]
            if node.isEnd {
                // 发现敏感词，替换
                for k := start; k <= j; k++ {
                    result[k] = replaceRune
                }
                i = j
                break
            }
        }
    }

    return string(result)
}


// LoadFromFile  从文件中加载敏感词
func (t *Trie) LoadFromFile(filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
        return err
    }
    defer file.Close()

    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                break
            }
            return err
        }
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
        t.Insert(line)
    }
    return nil
}

func main() {
    trie := NewTrie()

    // 1. 从文件加载敏感词
    err := trie.LoadFromFile("sensitive_words.txt") 
    if err != nil {
        log.Println("加载敏感词文件失败:", err)
        // 如果加载失败，使用默认敏感词
		trie.Insert("fuck")
		trie.Insert("shit")
    }


	// 2. 添加/删除敏感词
    trie.Insert("尼玛")
    trie.Delete("shit")

	// 3. 文本过滤
    text1 := "这是一段测试文本，包含fuck和尼玛，还有一些正常内容。"
    filteredText1 := trie.Filter(text1, '*')
    fmt.Println("过滤前:", text1)
    fmt.Println("过滤后:", filteredText1)

	text2 := "你好，世界，没有敏感词！"
    filteredText2 := trie.Filter(text2, '*')
    fmt.Println("过滤前:", text2)
    fmt.Println("过滤后:", filteredText2)
	
	// 4. 测试 Contains
	fmt.Println("Contains 'fuck':", trie.Contains("fuck")) // true
	fmt.Println("Contains 'shit':", trie.Contains("shit")) // false
	fmt.Println("Contains '尼玛':", trie.Contains("尼玛")) // true
}