本文目录导读：
模糊规则的实现方法。
基础模糊匹配脚本
Python 版本
import re
from pathlib import Path
def fuzzy_match_content(file_path, patterns, case_sensitive=False):
"""
模糊匹配文件内容
:param file_path: 文件路径
:param patterns: 匹配模式列表
:param case_sensitive: 是否区分大小写
:return: 匹配结果列表
"""
results = []
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
if not case_sensitive:
content = content.lower()
for pattern in patterns:
# 模糊匹配
if not case_sensitive:
search_pattern = pattern.lower()
else:
search_pattern = pattern
# 使用正则表达式进行模糊匹配
matches = re.finditer(search_pattern, content)
for match in matches:
start = max(0, match.start() - 50)
end = min(len(content), match.end() + 50)
results.append({
'pattern': pattern,
'matched_text': match.group(),
'context': content[start:end],
'position': match.start()
})
except Exception as e:
print(f"读取文件错误: {e}")
return results
# 使用示例
if __name__ == "__main__":
patterns = [r'error.*occurred', r'critical\s+failure', r'warning.*\d+']
matches = fuzzy_match_content('log.txt', patterns)
for match in matches:
print(f"模式: {match['pattern']}")
print(f"匹配文本: {match['matched_text']}")
print(f"上下文: ...{match['context']}...")
print("-" * 50)
Shell 脚本实现
#!/bin/bash
# 模糊匹配文件内容
fuzzy_match() {
local file=$1
local pattern=$2
if [[ ! -f "$file" ]]; then
echo "文件不存在: $file"
return 1
fi
# 使用 grep 进行模糊匹配
grep -n -i -E "$pattern" "$file" | while IFS=: read -r line_num line_content; do
echo "行号: $line_num"
echo "内容: $line_content"
echo "---"
done
}
# 批量匹配
batch_fuzzy_match() {
local file=$1
shift
local patterns=("$@")
for pattern in "${patterns[@]}"; do
echo "匹配模式: $pattern"
fuzzy_match "$file" "$pattern"
echo "===================="
done
}
# 使用示例
batch_fuzzy_match "system.log" "error.*timeout" "failed.*connection" "critical"
高级模糊匹配 - 相似度计算
import difflib
import re
from typing import List, Tuple
class FuzzyMatcher:
def __init__(self, threshold=0.8):
self.threshold = threshold
def calculate_similarity(self, text1: str, text2: str) -> float:
"""计算文本相似度"""
return difflib.SequenceMatcher(None, text1, text2).ratio()
def fuzzy_search(self, content: str, pattern: str) -> List[Tuple[str, float]]:
"""模糊搜索相似文本"""
results = []
lines = content.split('\n')
for line in lines:
similarity = self.calculate_similarity(line, pattern)
if similarity >= self.threshold:
results.append((line, similarity))
# 按相似度排序
results.sort(key=lambda x: x[1], reverse=True)
return results
def regex_fuzzy_match(self, content: str, patterns: List[str]) -> List[dict]:
"""正则模糊匹配"""
results = []
for pattern in patterns:
# 构建模糊正则表达式
fuzzy_pattern = self._build_fuzzy_regex(pattern)
matches = re.finditer(fuzzy_pattern, content)
for match in matches:
results.append({
'original_pattern': pattern,
'matched': match.group(),
'position': match.span()
})
return results
def _build_fuzzy_regex(self, pattern: str) -> str:
"""构建模糊正则表达式"""
# 允许字符间的缺失、插入和替换
fuzzy_parts = []
for char in pattern:
if char.isalnum():
fuzzy_parts.append(f'{char}.{{0,2}}')
else:
fuzzy_parts.append(re.escape(char))
return ''.join(fuzzy_parts)
# 使用示例
matcher = FuzzyMatcher(threshold=0.7)
content = "系统错误：连接超时，请重试"
pattern = "系统错误：连接失败"
results = matcher.fuzzy_search(content, pattern)
for text, similarity in results:
print(f"相似度: {similarity:.2f} - {text}")
粗糙规则匹配器
class RoughRuleMatcher:
"""粗糙规则匹配器"""
def __init__(self):
self.rules = []
def add_rule(self, name: str, keywords: List[str],
min_match: int = 1, operator: str = 'or'):
"""
添加匹配规则
:param name: 规则名称
:param keywords: 关键词列表
:param min_match: 最小匹配数
:param operator: 逻辑运算符 ('or', 'and')
"""
self.rules.append({
'name': name,
'keywords': keywords,
'min_match': min_match,
'operator': operator
})
def match_content(self, content: str) -> List[dict]:
"""匹配内容"""
results = []
content_lower = content.lower()
for rule in self.rules:
matched_keywords = []
for keyword in rule['keywords']:
if keyword.lower() in content_lower:
matched_keywords.append(keyword)
# 判断是否满足规则
if rule['operator'] == 'or':
if len(matched_keywords) >= rule['min_match']:
results.append({
'rule_name': rule['name'],
'matched_keywords': matched_keywords,
'match_count': len(matched_keywords)
})
elif rule['operator'] == 'and':
if len(matched_keywords) >= len(rule['keywords']):
results.append({
'rule_name': rule['name'],
'matched_keywords': matched_keywords,
'match_count': len(matched_keywords)
})
return results
# 使用示例
matcher = RoughRuleMatcher()
# 添加规则
matcher.add_rule(
'错误检测',
keywords=['error', 'failed', 'exception', 'timeout'],
min_match=2,
operator='or'
)
matcher.add_rule(
'安全威胁',
keywords=['attack', 'malware', 'unauthorized', 'breach'],
min_match=1,
operator='or'
)
# 匹配文件
content = "系统发生错误：连接超时，攻击检测到"
results = matcher.match_content(content)
for result in results:
print(f"规则: {result['rule_name']}")
print(f"匹配关键词: {result['matched_keywords']}")
print(f"匹配数量: {result['match_count']}")
完整文件处理脚本
#!/usr/bin/env python3
import os
import sys
import argparse
from pathlib import Path
import re
from typing import List, Dict, Any
class FileFuzzyMatcher:
"""文件模糊匹配器"""
def __init__(self):
self.patterns = []
self.rules = []
def process_file(self, file_path: str) -> Dict[str, Any]:
"""处理单个文件"""
result = {
'file': file_path,
'matches': [],
'errors': []
}
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 执行模糊匹配
for pattern in self.patterns:
matches = self._fuzzy_match(content, pattern)
result['matches'].extend(matches)
# 执行规则匹配
for rule in self.rules:
rule_matches = self._apply_rule(content, rule)
result['matches'].extend(rule_matches)
except Exception as e:
result['errors'].append(str(e))
return result
def process_directory(self, dir_path: str, extension: str = None) -> List[Dict]:
"""处理目录中的文件"""
results = []
path = Path(dir_path)
for file_path in path.rglob('*'):
if file_path.is_file():
if extension and file_path.suffix != extension:
continue
result = self.process_file(str(file_path))
if result['matches']:
results.append(result)
return results
def add_pattern(self, pattern: str, description: str = ""):
"""添加匹配模式"""
self.patterns.append({
'pattern': re.compile(pattern),
'description': description
})
def add_rule(self, rule: Dict):
"""添加匹配规则"""
self.rules.append(rule)
# 主函数
def main():
parser = argparse.ArgumentParser(description='文件内容模糊匹配工具')
parser.add_argument('path', help='文件或目录路径')
parser.add_argument('-p', '--pattern', action='append',
help='匹配模式（可多次使用）')
parser.add_argument('-e', '--extension', help='文件扩展名过滤')
parser.add_argument('-r', '--recursive', action='store_true',
help='递归处理子目录')
args = parser.parse_args()
matcher = FileFuzzyMatcher()
# 添加默认模式
if args.pattern:
for pattern in args.pattern:
matcher.add_pattern(pattern)
else:
# 默认模式
matcher.add_pattern(r'error|failed|exception|timeout', '错误关键词')
matcher.add_pattern(r'\d{4}-\d{2}-\d{2}', '日期格式')
# 处理文件或目录
if os.path.isfile(args.path):
results = [matcher.process_file(args.path)]
elif os.path.isdir(args.path):
results = matcher.process_directory(args.path, args.extension)
else:
print(f"路径不存在: {args.path}")
sys.exit(1)
# 输出结果
for result in results:
print(f"\n文件: {result['file']}")
if result['matches']:
for match in result['matches']:
print(f" 匹配: {match.get('pattern', match.get('rule_name', ''))}")
print(f" 内容: {match.get('matched_text', match.get('matched_keywords', ''))}")
if result['errors']:
print(f" 错误: {result['errors']}")
if __name__ == "__main__":
main()
使用建议
-
选择合适的匹配策略：
- 简单模糊：使用通配符和正则表达式
- 精确模糊：使用文本相似度算法
- 规则匹配：定义关键词组合规则
-
性能优化：
- 对大文件使用流式读取
- 使用编译后的正则表达式
- 缓存匹配结果
-
错误处理：
- 处理编码问题
- 处理大文件内存溢出
- 处理权限问题
这个实现可以根据你的具体需求进行定制和扩展。
