脚本如何实现文件内容模糊粗糙规则

本文目录导读：

1. 基础模糊匹配脚本
2. Shell 脚本实现
3. 高级模糊匹配 - 相似度计算
4. 粗糙规则匹配器
5. 完整文件处理脚本
6. 使用建议

模糊规则的实现方法。

基础模糊匹配脚本

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()

使用建议

1. 选择合适的匹配策略：

   • 简单模糊：使用通配符和正则表达式
   • 精确模糊：使用文本相似度算法
   • 规则匹配：定义关键词组合规则

2. 性能优化：

   • 对大文件使用流式读取
   • 使用编译后的正则表达式
   • 缓存匹配结果

3. 错误处理：

   • 处理编码问题
   • 处理大文件内存溢出
   • 处理权限问题

这个实现可以根据你的具体需求进行定制和扩展。