敏感字符过滤

最新推荐文章于 2025-06-19 15:03:44 发布
原创 最新推荐文章于 2025-06-19 15:03:44 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#敏感字

本文介绍了一种基于树形结构的敏感词过滤算法，并提供了C++和C#两种语言的具体实现。通过构建敏感词树，可以高效地检测并替换文本中的敏感词汇。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

WordNode.h
#ifndef __TOOLS_WORDNODE_H_INCLUDE__
#define __TOOLS_WORDNODE_H_INCLUDE__

#include <map>

class CWordNode

{

typedef std::map<std::string, CWordNode*> umap;

public:
CWordNode(const std::string& word) { Reset(word); }
~CWordNode()
{
umap::iterator Ite = this->m_mapWordNodes.begin();
while (Ite != this->m_mapWordNodes.end())
{
CWordNode* pTmp = Ite->second;
delete pTmp;
pTmp = NULL;
++Ite;
}

this->m_mapWordNodes.clear();
this->m_nEndTag = 0;
}

void Reset(const std::string& word) 
{
this->m_cWord   = word;
this->m_nEndTag = 0;
this->m_mapWordNodes.clear();
}

public:
std::string                      m_cWord;
int                              m_nEndTag;
umap                             m_mapWordNodes;
};


#endif // __TOOLS_WORDNODE_H_INCLUDE__

WordsFilter.h
#ifndef __TOOLS_WORDSFILTER_H_INCLUDE__
#define __TOOLS_WORDSFILTER_H_INCLUDE__

#include <list>
#include "WordNode.h"

class CWordsFilter
{
typedef std::map<std::string, CWordNode*> umap;
private:
std::list<std::string> m_lsAllSensitiveWords; // 所有敏感词列表
CWordNode*             m_rootWordNode;
bool                   m_bIsInit;

public:
CWordsFilter();
~CWordsFilter();

static CWordsFilter&  GetInstance(); // 获取共享实例

void                   InitSensitiveWords(std::string strWord);                        // 初始化敏感词集
void                   InitSensitiveWords(std::list<std::string> lsAllSensitiveWords); // 初始化敏感词集
std::string            FilterSensitiveWords(const std::string& strContent);      // 过滤敏感词

private:
void                   BuildWordTree(); // 构建敏感词树
void                   InsertNode(CWordNode* pNode, const std::string& strContent, int nIndex);
CWordNode*             FindNode(CWordNode* pNode, const std::string& word);
int                    GetFirstBytes(const std::string& str); // 获取字符串中的第一个字符字节长度
};

#endif // __TOOLS_WORDSFILTER_H_INCLUDE__

WordsFilter.cpp
#include <iostream>
#include <sstream>
#include <fstream>
#include <cmath>
#include "WordsFilter.h"

int nStep = 2;

typedef std::vector<std::string> Tokens;
Tokens StrSplit(const std::string &src, const std::string &sep)
{
Tokens r;
std::string s;

for (std::string::const_iterator i = src.begin(); i != src.end(); i++)
{
if (sep.find((*i)) != std::string::npos)
{
if (s.length())
{
r.push_back(s);
}
s = "";
}
else
{
s += (*i);
}
}

if (s.length())
{
r.push_back(s);
}
return r;
};

int CWordsFilter::GetFirstBytes(const std::string& str)
{
for (int i = 0; i < (int)str.size(); ++i)
{
unsigned char chr = (unsigned char)str.at(i);
// 如果是该字节是 0XXX XXXX 样式，说明其是一个英文文字，占1字节
if ((chr >> 7) == 0)
{
return 1;
}
// 如果该字节是 1111 110X 样式，说明其是一个文字的头，且该文字占6字节
else if ((chr >> 1) == 126)
{
return 6;
}
// 如果该字节是 1111 10XX 样式，说明其是一个文字的头，且该文字占5字节
else if ((chr >> 2) == 62)
{
return 5;
}
// 如果该字节是 1111 0XXX 样式，说明其是一个文字的头，且该文字占4字节
else if ((chr >> 3) == 30)
{
return 4;
}
// 如果该字节是 1110 XXXX 样式，说明其是一个文字的头，且该文字占3字节
else if ((chr >> 4) == 14)
{
return 3;
}
// 如果该字节是 110X XXXX 样式，说明其是一个文字的头，且该文字占2字节
else if ((chr >> 5) == 6)
{
return 2;
}
else
{
continue;
}
}
return 1;
}

CWordsFilter::CWordsFilter():
m_bIsInit(false),
m_rootWordNode(NULL)
{
m_lsAllSensitiveWords.clear();
}

CWordsFilter::~CWordsFilter()
{
this->m_lsAllSensitiveWords.clear();
delete this->m_rootWordNode;
this->m_rootWordNode = NULL;
}

void CWordsFilter::InitSensitiveWords(std::string strWord)
{
Tokens token = StrSplit(strWord, ",");
std::list<std::string> lsAllSensitiveWords;
Tokens::iterator Ite = token.begin();
while (Ite != token.end())
{
lsAllSensitiveWords.push_back(*Ite);
++Ite;
}
InitSensitiveWords(lsAllSensitiveWords);
}

void CWordsFilter::InitSensitiveWords(std::list<std::string> lsAllSensitiveWords)
{
std::cout << "start init sensitive words" << std::endl;
this->m_lsAllSensitiveWords.clear();
this->m_lsAllSensitiveWords = lsAllSensitiveWords;

BuildWordTree();
this->m_bIsInit = true;
}

std::string CWordsFilter::FilterSensitiveWords(const std::string& strContent)
{
if (!this->m_bIsInit || NULL == this->m_rootWordNode)
{
std::cout << "the sensitive words is not init" << std::endl;
return "";
}

CWordNode* pNode = this->m_rootWordNode;

std::string strBuffer = "";
std::list<std::string> lsBad;
int a = 0;
while ( a < strContent.size() )
{
std::string strContentTmp = strContent.substr(a, strContent.size());
nStep = GetFirstBytes(strContentTmp);
std::string strTmp = "";
if (nStep <= strContentTmp.size())
{
strTmp = strContentTmp.substr(0, nStep);
}
pNode = FindNode(pNode, strTmp);
if (pNode == NULL)
{
pNode = this->m_rootWordNode;
int nSize = 0;
std::list<std::string>::iterator Ite = lsBad.begin();
while (Ite != lsBad.end())
{
nSize += (*Ite).size();
++Ite;
}
if (lsBad.size() > 0)
{
lsBad.clear();
}
a = a - nSize;
if (a < 0) 
{
a = 0;
}
std::string strContentTmp = strContent.substr(a, strContent.size());
nStep = GetFirstBytes(strContentTmp);
strTmp = "";
if (nStep <= strContentTmp.size())
{
strTmp = strContentTmp.substr(0, nStep);
}
strBuffer.append(strTmp);
}
else if (pNode->m_nEndTag == 1)
{
lsBad.push_back(strTmp);
for (int nIndex = 0; nIndex < lsBad.size(); ++nIndex)
{
strBuffer.append("*");
}
pNode = this->m_rootWordNode;
lsBad.clear();
}
else
{
lsBad.push_back(strTmp);
if (a == strContent.size() - nStep)
{
std::list<std::string>::const_iterator cIte = lsBad.begin();
while (cIte != lsBad.end())
{
strBuffer.append(*cIte);
++cIte;
}
}
}
strContentTmp = strContentTmp.substr(nStep, strContentTmp.size());
a += nStep;
}

return strBuffer;
}

void CWordsFilter::BuildWordTree()
{
if ( this->m_rootWordNode == NULL )
{
this->m_rootWordNode = new CWordNode("R");
if (NULL == this->m_rootWordNode)
{
return;
}
}
this->m_rootWordNode->Reset("R");

std::list<std::string>::const_iterator cIte = this->m_lsAllSensitiveWords.begin();
while (cIte != this->m_lsAllSensitiveWords.end())
{
std::string strTmp = (*cIte);

if (strTmp.size() > 0)
{
InsertNode(this->m_rootWordNode, strTmp, 0);
}
++cIte;
}
}

void CWordsFilter::InsertNode(CWordNode* pNode, const std::string& strContent, int nIndex)
{
if (NULL == pNode)
{
return;
}
nStep = GetFirstBytes(strContent);
std::string strTmp = "";
if (nStep <= strContent.size())
{
strContent.substr(0, nStep);
}
CWordNode* pN = FindNode(pNode, strTmp);
if (NULL == pN)
{
pN = new CWordNode(strTmp);
if (NULL == pN)
{
return;
}
pNode->m_mapWordNodes[strTmp] = pN;
}

if (nIndex == strContent.size() - nStep)
{
pN->m_nEndTag = 1;
}

strTmp = strContent.substr(nStep, strContent.size());

if (strTmp.size() > 0)
{
InsertNode(pN, strTmp, 0);
}
}

CWordNode* CWordsFilter::FindNode(CWordNode* pNode, const std::string& word)
{
if ( NULL == pNode )
{
return NULL;
}
umap::iterator Ite = pNode->m_mapWordNodes.find(word);
if (Ite != pNode->m_mapWordNodes.end())
{
return Ite->second;
}

return NULL;
}

CWordsFilter& CWordsFilter::GetInstance()
{
static CWordsFilter inst;
return inst;

}

以上是C++实现的

-------------------------------------------------------------分割线---------------------------------------------------------------------

下面是C#实现的

sealed class WordNode : IDisposable
{
public WordNode(string word)
{
Reset(word);
}

public void Reset(string word)
{
this.word = word;
endTag = 0;
wordNodes.Clear();
}

public void Dispose()
{
Reset(string.Empty);
}

public string word;
public int endTag;
public Dictionary<string, WordNode> wordNodes = new Dictionary<string,WordNode>();
}

public class WordFilter
{
private List<string> allSensitiveWords = new List<string>();
private WordNode rootWordNode = null;
private bool isInit = false;

private WordFilter()
{
allSensitiveWords.Clear();
isInit = false;
rootWordNode = new WordNode(null);
}

public void InitSensitiveWords(string words)
{
string[] wordArr = words.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
this.allSensitiveWords.Clear();
for (int index = 0; index < wordArr.Length; ++index)
{
this.allSensitiveWords.Add(wordArr[index]);
}
BuildWordTree();
this.isInit = true;

}


public string FilterSensitiveWords(string content)
{
if (!isInit || null == rootWordNode)
{
Console.WriteLine("the sensitive word is not init");
return content;
}

WordNode node = this.rootWordNode;
StringBuilder buffer = new StringBuilder();
List<string> badLst = new List<string>();
int a = 0;
while (a < content.Length)
{
string contnetTmp = content.Substring(a);
string strTmp = contnetTmp.Substring(0, 1);
node = FindNode(node, strTmp);
if (null == node)
{
node = this.rootWordNode;
a = a - badLst.Count;
if (a < 0)
{
a = 0;
}
badLst.Clear();
string beginContent = content.Substring(a);
if (beginContent.Length > 0)
{
buffer.Append(beginContent[0]);
}
}
else if (node.endTag == 1)
{
badLst.Add(strTmp);
for (int index = 0; index < badLst.Count; ++index)
{
buffer.Append("*");
}
node = this.rootWordNode;
badLst.Clear();
}
else
{
badLst.Add(strTmp);
if (a == content.Length - 1)
{
for (int index = 0; index < badLst.Count; ++index)
{
buffer.Append(badLst[index]);
}
}
}

contnetTmp = contnetTmp.Substring(1);
++a;
}

return buffer.ToString();
}

public bool IsHasSensitiveWord(string content)
{
if (!isInit || null == rootWordNode)
{
Console.WriteLine("the sensitive word is not init");
return false;
}

WordNode node = this.rootWordNode;
StringBuilder buffer = new StringBuilder();
List<string> badLst = new List<string>();
int a = 0;
while (a < content.Length)
{
string contnetTmp = content.Substring(a);
string strTmp = contnetTmp.Substring(0, 1);
node = FindNode(node, strTmp);
if (null == node)
{
node = this.rootWordNode;
a = a - badLst.Count;
if (a < 0)
{
a = 0;
}
badLst.Clear();
}
else if (node.endTag == 1)
{
return true;
}
else
{
badLst.Add(strTmp);
}

contnetTmp = contnetTmp.Substring(1);
++a;
}

return false;
}

private void BuildWordTree()
{
if (null == this.rootWordNode)
{
this.rootWordNode = new WordNode("R");
}
this.rootWordNode.Reset("R");
for (int index = 0; index < this.allSensitiveWords.Count; ++index)
{
string strTmp = this.allSensitiveWords[index];
if (strTmp.Length > 0)
{
InsertNode(this.rootWordNode, strTmp);
}
}
}

private void InsertNode(WordNode node, string content)
{
if (null == node)
{
Console.WriteLine("the root node is null");
return;
}
string strTmp = content.Substring(0, 1);
WordNode wordNode = FindNode(node, strTmp);
if (null == wordNode)
{
wordNode = new WordNode(strTmp);
node.wordNodes[strTmp] = wordNode;
}

strTmp = content.Substring(1);
if (string.IsNullOrEmpty(strTmp))
{
wordNode.endTag = 1;
}
else
{
InsertNode(wordNode, strTmp);
}
}

private WordNode FindNode(WordNode node, string content)
{
if (null == node)
{
return null;
}

WordNode wordNode = null;
node.wordNodes.TryGetValue(content, out wordNode);
return wordNode;
}

private static WordFilter instance = null;
public static WordFilter Instance
{
get
{
if (null == instance)
{
instance = new WordFilter();
}
return instance;
}
}
}


（轻量比较集全的）敏感字符集
06-07
敏感字符集 网络敏感字 敏感 网站敏感字符
php表单敏感字符过滤类
10-25
敏感字符过滤类通常包含了处理和过滤用户输入数据的方法，以防止恶意输入。以下是一个简单的`formHtmlFind`类的示例，它用于生成表单并处理表单数据的过滤： ```php class formHtmlFind { // ... public ...
spring-mvc 乱码问题的处理
abaidaye的博客
03-28 180
乱码问题的处理 当处理post请求时容易出现乱码，如果不是前端页面的问题的话，我们需要加入过滤器处理 大前提，tomcat要设置好 点开对应文件—conf-server.xml–找到connector <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" /> 第一种方式— 自定义过
C#实现文本敏感字符过滤与替换
最新发布
weixin_42602368的博客
06-19 373
在今天的数字化社会中，信息安全已成为企业和个人都无法忽视的课题。敏感字符过滤与替换作为信息安全的基础技术之一，在维护网络环境的清洁、保护用户隐私及防止敏感信息泄露等方面扮演着重要角色。本章节将介绍敏感字符过滤与替换的基本概念、应用场景及重要性，为后续章节深入探讨C#文本处理技术及实现细节奠定基础。敏感字符过滤与替换通常涉及对特定文本内容进行检查并替换掉其中的敏感词汇。为了实现这一功能，我们往往需要建立一个包含所有敏感词汇的“黑名单”，当用户输入或文本文件中出现这些词汇时，系统将自动进行处理。
过滤敏感字符
一如既叼的博客
12-24 359
/** * 验证有无敏感字符 * @author heshuang * @date 20191224 */ public boolean checkParams(String param) { String reg = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|" ...
php表单敏感字符过滤代码类
05-02
"php表单敏感字符过滤代码类"提供了一种解决方案，旨在防止恶意用户利用敏感字符注入攻击，如SQL注入或跨站脚本（XSS）攻击。下面将详细解释这个代码类涉及的知识点及其重要性。 首先，我们要理解表单数据的收集。...
php表单敏感字符过滤代码类.zip
07-11
"php表单敏感字符过滤代码类.zip"提供的就是一个专门用于处理这类问题的PHP类库，它包含了对表单数据进行过滤和验证的功能。 这个类库的主要功能包括： 1. **表单函数输出**：类库可能包含自定义的函数，用于生成...
php的表单敏感字符过滤类.zip
07-11
<?php $_form = new formHtmlFind(); class formHtmlFind{ public function formHtml($array,$...if(empty($array))return false;...这是一个php表单敏感字符过滤类及其用法。分享给大家供大家参考。
网络敏感词检测----SensitivewordFilter-匹配度低，速度快
04-07
网络敏感词检测----SensitivewordFilter-匹配度低，速度快
对敏感字符**处理
06-06
手机号，银行卡等脱敏显示 把部分字符*号处理工具类 正则匹配
2014年最近整理的，合并了多个敏感字符集的敏感字符列表，按照竖线分割的
02-18
2014年最近整理的，合并了多个敏感字符集的敏感字符列表，按照竖线分割的
funNLP：中英文敏感词，语言检测，中外手机电话归属地运营商查询，名字性别，手机号删除，身份证提取，邮箱删除，中日文人名库，中文缩写库，拆字词典，词汇情感值，停用词，反动词表，暴恐词表，繁简体转换，英语模拟中文最佳，汪峰歌词生成器，职业名称词库，词典库，反义词库，否定词库，汽车品牌词库，汽车零件词库，连续英文切割，各种中文词向量，公司名称大全，古诗词库，IT词库，财经词库，成语词库，地名库，历史名人词库，诗词词库，医学词库，饮食词库，法律词库，汽车词库，动物词库，中文聊天语料，中文谣言数据，百度中文查询
02-09
NLP民工的乐园 最强大的NLP武器库 NLP民工的乐园：几乎最全的中文NLP资源库 词库 工具包 学习资料 在入门到熟悉NLP的过程中，用到了很多github上的包，遂整理了一下，分享在这里。 很多包非常有趣，值得收藏，满足大家的收集癖！如果觉得有用，请分享并star，谢谢！ 长期不定时更新，欢迎手表和叉子！ 涉及内容包括但不限于：中英文敏感词，语言检测，中外手机/电话归属​​地/运营商查询，名字，名称，性别，手机号撤回，身份证删除，邮箱删除，中日文人名库，中文缩写库，拆字字典，词汇情感值，替换词，反动词表，暴恐词表，繁简体转换，英文模拟中文最佳，汪峰歌词生成器，职业名称词库，词典库，反义词库，否定词库，汽车品牌词库，汽车零件词库，连续英语切割，各种中文词向量，公司名称大全，古诗词库，IT词库，财经词库，成语词库，地名库，历史名人词库，诗词词库，医学词库，饮食词库，法律词库，汽车词库，动
Filter过滤敏感字符
xiaobiaobiao521的专栏
05-09 916
思想：一些公司对request进行包装，过滤后存入数据库，                        好的做法是包装response存入数据库后读取时再过滤                        也可以用自定义书签来实现            Note:            配置     SensitiveFilter     SensitiveFi
敏感字符过滤器
yang______t的博客
10-05 385
很多网站都需要对于某些关键字或者某些敏感词汇进行过滤替换的功能。比如在输入框中输入些js 脚本，或者输入些政府类型的词汇等都是不允许的，但是你不能限制用户的自由。所以对于网站的过滤功能就显得很有必要了。对于一般的网站使用来说，不需要非常复杂的过滤算法等比较高端的实现。简单的用 filter 和 HttpServletRequestWrapper 就可以实现。 HttpServletRequestWrapper 的实现采用了包装模式，具体介绍请另找资料。直接切入正题。实现思路：首先定义一个 propertie
敏感字符过滤算法
weixin_30781433的博客
07-11 154
package com.lala.teamtoneback.code.common.util; import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/** * 算法思路：把敏感词的第一个字符取出来，作为比较对象。 * 遍历整个字符串，如果发现字符跟敏感词第...
常见的敏感词过滤方案汇总以及高效工具sensitive-word快速实践！
热门推荐
qq_59622162的博客
01-18 1万+
本文主要对目前常见的敏感词过滤方案进行汇总以及对GitHub热门开源sensitive-word项目介绍以及快速上手
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值