根据关键词智能过滤 Linux Do 论坛上的水贴，支持 SPA 页面切换
// ==UserScript==
// @name Linux DO 关键词过滤器
// @namespace http://tampermonkey.net/
// @version 0.5
// @description 根据关键词智能过滤 Linux Do 论坛上的水贴，支持 SPA 页面切换
// @author whiteSnow
// @match https://linux.do/*
// @match https://*.discourse.org/*
// @grant GM_addStyle
// @grant GM_getValue
// @grant GM_setValue
// @license MIT
// ==/UserScript==
(function() {
'use strict';
// 序列化处理（解决正则表达式无法直接存储的问题）
function serializeKeywordGroups(groups) {
return JSON.stringify(groups, (key, value) => {
if (value instanceof RegExp) {
return { __type: 'RegExp', source: value.source, flags: value.flags };
}
return value;
});
}
// 反序列化处理
function deserializeKeywordGroups(jsonStr) {
return JSON.parse(jsonStr, (key, value) => {
if (value?.__type === 'RegExp') {
return new RegExp(value.source, value.flags);
}
return value;
});
}
// 关键词分组配置 - 使用更精确的匹配模式
const DEFAULT_KEYWORD_GROUPS = {
'水贴': [
{ words: ['恭喜', '通过',"赞",'好'], minCount: 1,maxLength:10 }, // 同时包含这些词中至少2个
{ words: ['骚扰'], context: ['欢迎', '邮箱'],maxLength:10 }, // 包含"骚扰"且上下文中有"欢迎"或"邮箱"
{ words: ['申请'], context: ['通过', '审核', '等待'], maxLength: 10 }, // 包含"申请"且上下文有相关词，且内容较短
{ exact: '期待ing' }, // 精确匹配
{ regex: /\b申请.*?(通过|成功)\b/i,maxLength:10 } // 正则匹配
],
'感谢':[
{ words: ['感谢','谢谢'],maxLength:15},
],
'大佬':[
{ words: ['大佬','太强了','厉害','牛逼','牛','大佬牛逼','大佬厉害','大佬牛','tql','666'],maxLength:15},
],
'打卡':[
{ words: ['打卡','签到','签个到','打个卡','来了','来来来','前排','支持','围观'],maxLength:15},
// { words: ['Mark', 'mark', '马克'],maxLength:10}, //添加mark，by snowsoul
{ regex: /\b(mark|马克)\b/i,maxLength:10}, //添加mark，by snowsoul
],
'技术': [
{ words: ['代码', '问题'], minCount: 1, context: ['解决', '实现', '如何'],maxLength:20 },
{ words: ['教程', '学习'], context: ['方法', '步骤'] ,maxLength:50},
{ regex: /\b(bug|error|exception|failed)\b/i,maxLength:20 }
],
};
let keywordGroups = DEFAULT_KEYWORD_GROUPS;
if (!GM_getValue("defaultKeywordGroups")) {
GM_setValue("defaultKeywordGroups", serializeKeywordGroups(DEFAULT_KEYWORD_GROUPS));
}
// 添加过滤统计面板样式
GM_addStyle(`
#filter-stats {
position: fixed;
top: 70px;
left: 20px;
background: #fff;
border: 1px solid #ddd;
border-radius: 5px;
padding: 10px;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
z-index: 1000;
font-size: 14px;
min-width: 180px;
}
#filter-stats h3 {
margin: 0 0 10px 0;
font-size: 16px;
border-bottom: 1px solid #eee;
padding-bottom: 5px;
}
.filter-group {
display: flex;
justify-content: space-between;
margin-bottom: 5px;
}
.filter-count {
font-weight: bold;
color: #e45735;
}
.filter-toggle {
cursor: pointer;
user-select: none;
display: block;
margin-top: 10px;
text-align: center;
color: #0088cc;
}
.filter-settings {
cursor: pointer;
user-select: none;
display: block;
margin-top: 5px;
text-align: center;
color: #0088cc;
font-size: 12px;
}
.filtered-post {
opacity: 0.4;
position: relative;
}
.filtered-post::before {
content: attr(data-filter-reason);
position: absolute;
top: 10px;
right: 10px;
background: rgba(228, 87, 53, 0.8);
color: white;
padding: 2px 8px;
border-radius: 3px;
font-size: 12px;
z-index: 10;
}
.filtered-post.hidden {
display: none !important;
}
.confidence-high::before {
background: rgba(228, 87, 53, 0.9);
}
.confidence-medium::before {
background: rgba(255, 152, 0, 0.9);
}
.confidence-low::before {
background: rgba(158, 158, 158, 0.9);
}
#filter-settings-panel {
display: none;
position: fixed;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
background: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 4px 20px rgba(0,0,0,0.2);
z-index: 1001;
width: 400px;
max-height: 80vh;
overflow-y: auto;
}
.settings-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 15px;
}
.settings-close {
cursor: pointer;
font-size: 20px;
}
.settings-group {
margin-bottom: 15px;
border-bottom: 1px solid #eee;
padding-bottom: 10px;
}
.settings-group-title {
font-weight: bold;
margin-bottom: 8px;
}
.settings-threshold {
margin-top: 15px;
}
.settings-threshold label {
display: block;
margin-bottom: 5px;
}
.settings-actions {
margin-top: 15px;
text-align: right;
}
.settings-actions button {
padding: 5px 15px;
margin-left: 10px;
border-radius: 4px;
border: 1px solid #ddd;
background: #f5f5f5;
cursor: pointer;
}
.settings-actions button.save {
background: #0088cc;
color: white;
border-color: #0088cc;
}
#filter-debug {
position: fixed;
bottom: 10px;
right: 10px;
background: rgba(0,0,0,0.7);
color: white;
padding: 5px 10px;
border-radius: 3px;
font-size: 12px;
z-index: 1001;
display: none;
}
#filter-stats {
position: fixed;
cursor: default;
}
#filter-stats h3 {
cursor: grab;
padding: 8px 12px; /* 增加点击区域 */
margin: 0;
}
#filter-stats h3:active {
cursor: grabbing;
}
/* 新增圆形按钮样式 */
.filter-toggle-button {
position: fixed;
width: 40px;
height: 40px;
border-radius: 50%;
background: rgb(209.1, 239.7, 255);
cursor: move;
box-shadow: 0 2px 10px rgba(0,0,0,0.2);
display: flex;
align-items: center;
justify-content: center;
color: black;
font-size: 14px;
z-index: 9999;
transition: transform 0.2s;
}
.filter-toggle-button:hover {
transform: scale(1.1);
}
/* 调整统计面板为弹出式 */
#filter-stats {
display: none;
position: fixed;
min-width: 250px;
z-index: 1001;
border-radius: 8px;
box-shadow: 0 4px 20px rgba(0,0,0,0.2);
}
#filter-stats.visible {
display: block;
animation: fadeIn 0.3s;
}
@keyframes fadeIn {
from { opacity: 0; transform: translateY(-10px); }
to { opacity: 1; transform: translateY(0); }
}
`);
// 修改最后三个属性的样式，因为使用 fixed 定位，故需要修改为 left/top ，方便计算位置
// 修改创建面板的函数
function createFilterStatsPanel() {
// 创建圆形按钮
const toggleBtn = document.createElement('div');
toggleBtn.className = 'filter-toggle-button';
toggleBtn.innerHTML = '滤';
document.body.appendChild(toggleBtn);
// 获取当前隐藏状态
const hideFiltered = GM_getValue('hideFiltered', false);
// 创建统计面板
const panel = document.createElement('div');
panel.id = 'filter-stats';
// panel.innerHTML = `
// <h3>关键词过滤统计</h3>
// <div id="filter-groups"></div>
// <div class="filter-settings" id="open-settings">过滤设置</div>
// `;
panel.innerHTML = `
<h3>关键词过滤统计</h3>
<div id="filter-groups"></div>
<div class="filter-toggle" id="toggle-filter">${hideFiltered ? '显示' : '隐藏'}已过滤帖子</div>
<div class="filter-settings" id="open-settings">过滤设置</div>
`;
// 位置计算逻辑
function calculatePosition(btnRect) {
const panelWidth = 250;
const panelHeight = 200;
const viewportWidth = window.innerWidth;
const viewportHeight = window.innerHeight;
// 左下显示
if (btnRect.left + panelWidth + 60 > viewportWidth - 20 && btnRect.top + panelHeight < viewportHeight - 20) {
return {
left: btnRect.left - panelWidth - 10,
top: btnRect.top
};
}
// 左上显示
else if (btnRect.left + panelWidth + 60 > viewportWidth - 20 && btnRect.top + panelHeight > viewportHeight - 20) {
return {
left: btnRect.left - panelWidth - 10,
top: btnRect.top - panelHeight - 10
};
}
// 右上显示
else if (btnRect.top + panelHeight > viewportHeight - 20 ) {
return {
left: btnRect.left + btnRect.width + 10,
top: btnRect.top - panelHeight - 10
};
}
// 其他情况右下显示
else {
return {
left: btnRect.left + btnRect.width + 10,
top: btnRect.top
};
}
}
// 点击按钮切换面板
toggleBtn.addEventListener('click', function(e) {
e.stopPropagation();
const isVisible = panel.classList.contains('visible');
if (!isVisible) {
const btnRect = toggleBtn.getBoundingClientRect();
const pos = calculatePosition(btnRect);
panel.style.left = `${pos.left}px`;
panel.style.top = `${pos.top}px`;
panel.classList.add('visible');
} else {
panel.classList.remove('visible');
}
});
// 点击外部区域关闭面板
// document.addEventListener('click', function(e) {
// if (!panel.contains(e.target) && !toggleBtn.contains(e.target)) {
// panel.classList.remove('visible');
// }
// });
// 保持原有拖动功能（修改为拖动按钮）
let isDragging = false;
let startX, startY, initialX, initialY;
toggleBtn.addEventListener('mousedown', startDrag);
document.addEventListener('mousemove', drag);
document.addEventListener('mouseup', stopDrag);
// 恢复保存的位置
const savedPosition = GM_getValue('buttonPosition', { x: '20px', y: '70px' });
toggleBtn.style.left = savedPosition.x;
toggleBtn.style.top = savedPosition.y;
function startDrag(e) {
isDragging = true;
startX = e.clientX;
startY = e.clientY;
initialX = toggleBtn.offsetLeft;
initialY = toggleBtn.offsetTop;
toggleBtn.style.cursor = 'grabbing';
}
function drag(e) {
if (!isDragging) return;
const dx = e.clientX - startX;
const dy = e.clientY - startY;
const newX = Math.max(0, Math.min(window.innerWidth - toggleBtn.offsetWidth, initialX + dx));
const newY = Math.max(0, Math.min(window.innerHeight - toggleBtn.offsetHeight, initialY + dy));
toggleBtn.style.left = `${newX}px`;
toggleBtn.style.top = `${newY}px`;
}
function stopDrag() {
isDragging = false;
toggleBtn.style.cursor = 'pointer';
GM_setValue('buttonPosition', {
x: toggleBtn.style.left,
y: toggleBtn.style.top
});
}
document.body.appendChild(panel);
// 保持原有设置面板和过滤功能...
// 添加切换过滤显示/隐藏的事件
document.getElementById('toggle-filter').addEventListener('click', function() {
const hideFiltered = !GM_getValue('hideFiltered', false);
GM_setValue('hideFiltered', hideFiltered);
// 更新按钮文本
this.textContent = hideFiltered ? '显示已过滤帖子' : '隐藏已过滤帖子';
// 应用隐藏/显示状态
applyFilterVisibility();
});
// 添加设置面板打开事件
document.getElementById('open-settings').addEventListener('click', function() {
openSettingsPanel();
});
// 创建调试面板
const debugPanel = document.createElement('div');
debugPanel.id = 'filter-debug';
document.body.appendChild(debugPanel);
}
// 应用过滤帖子的隐藏/显示状态
function applyFilterVisibility() {
const hideFiltered = GM_getValue('hideFiltered', false);
const filteredPosts = document.querySelectorAll('.filtered-post');
filteredPosts.forEach(post => {
if (hideFiltered) {
post.classList.add('hidden');
} else {
post.classList.remove('hidden');
}
});
}
// 创建设置面板
function createSettingsPanel() {
// 如果已存在，则不重复创建
if (document.getElementById('filter-settings-panel')) return document.getElementById('filter-settings-panel');
const panel = document.createElement('div');
panel.id = 'filter-settings-panel';
let groupsHtml = '';
for (const group in keywordGroups) {
// 获取该组的启用状态
const enabled = GM_getValue(`enable-${group}`, true);
groupsHtml += `
<div class="settings-group">
<div class="settings-group-title">
<input type="checkbox" id="enable-${group}" ${enabled ? 'checked' : ''}>
<label for="enable-${group}">${group}</label>
</div>
<div class="group-rules" id="rules-${group}">
<div class="rule-count">${keywordGroups[group].length}条规则</div>
<button class="edit-rules" data-group="${group}">编辑规则</button>
</div>
</div>
`;
}
panel.innerHTML = `
<div class="settings-header">
<h3>过滤设置</h3>
<span class="settings-close" id="close-settings">×</span>
</div>
<div class="settings-tabs">
<div class="tab active" data-tab="general">常规设置</div>
<div class="tab" data-tab="groups">分组管理</div>
<div class="tab" data-tab="advanced">高级设置</div>
</div>
<div class="tab-content" id="tab-general">
<div class="settings-option">
<label>
<input type="checkbox" id="auto-hide-filtered" ${GM_getValue('hideFiltered', false) ? 'checked' : ''}>
自动隐藏已过滤的帖子
</label>
</div>
<div class="settings-length-threshold">
<label for="filter-length-threshold">长度阈值 (0-100):</label>
<input type="range" id="filter-length-threshold" min="0" max="100" value="${GM_getValue('filterLengthThreshold', 20)}" style="width: 100%">
<div class="threshold-display">
<span id="length-threshold-value">${GM_getValue('filterLengthThreshold', 20)}</span>
<span class="threshold-description">
(只要帖子长度低于该值, 且置信度较低，就会被过滤)
</span>
</div>
</div>
<div class="settings-threshold">
<label for="confidence-threshold">置信度阈值 (0-100):</label>
<input type="range" id="confidence-threshold" min="0" max="100" value="${GM_getValue('confidenceThreshold', 60)}" style="width: 100%">
<div class="threshold-display">
<span id="threshold-value">${GM_getValue('confidenceThreshold', 60)}</span>
<span class="threshold-description">
(较低的值会过滤更多帖子，但可能误判；较高的值过滤更精确，但可能遗漏)
</span>
</div>
</div>
</div>
<div class="tab-content" id="tab-groups" style="display:none">
${groupsHtml}
<div class="add-group">
<button id="add-new-group">+ 添加新分组</button>
</div>
</div>
<div class="tab-content" id="tab-advanced" style="display:none">
<div class="settings-option">
<label>
<input type="checkbox" id="enable-debug" ${GM_getValue('enableDebug', false) ? 'checked' : ''}>
启用调试模式
</label>
</div>
<div class="settings-option">
<label>
<input type="checkbox" id="highlight-only" ${GM_getValue('highlightOnly', false) ? 'checked' : ''}>
仅高亮不隐藏（覆盖自动隐藏设置）
</label>
</div>
<div class="export-import">
<button id="export-settings">导出设置</button>
<button id="import-settings">导入设置</button>
</div>
</div>
<div class="settings-actions">
<button id="reset-settings">重置</button>
<button id="save-settings" class="save">保存</button>
</div>
`;
document.body.appendChild(panel);
// 添加事件监听
document.getElementById('close-settings').addEventListener('click', closeSettingsPanel);
document.getElementById('filter-length-threshold').addEventListener('input', function() {
document.getElementById('length-threshold-value').textContent = this.value;
});
document.getElementById('confidence-threshold').addEventListener('input', function() {
document.getElementById('threshold-value').textContent = this.value;
});
document.getElementById('save-settings').addEventListener('click', saveSettings);
document.getElementById('reset-settings').addEventListener('click', resetSettings);
// 添加标签切换功能
document.querySelectorAll('.settings-tabs .tab').forEach(tab => {
tab.addEventListener('click', function() {
// 移除所有标签的active类
document.querySelectorAll('.settings-tabs .tab').forEach(t => t.classList.remove('active'));
// 添加当前标签的active类
this.classList.add('active');
// 隐藏所有内容
document.querySelectorAll('.tab-content').forEach(content => {
content.style.display = 'none';
});
// 显示当前标签对应的内容
const tabId = this.getAttribute('data-tab');
document.getElementById(`tab-${tabId}`).style.display = 'block';
});
});
// 添加编辑规则按钮事件
document.querySelectorAll('.edit-rules').forEach(button => {
button.addEventListener('click', function() {
const group = this.getAttribute('data-group');
openRuleEditor(group);
});
});
// 添加新分组按钮事件
document.getElementById('add-new-group').addEventListener('click', addNewGroup);
// 添加导入导出功能
document.getElementById('export-settings').addEventListener('click', exportSettings);
document.getElementById('import-settings').addEventListener('click', importSettings);
return panel;
}
// 打开规则编辑器
function openRuleEditor(group) {
// 创建规则编辑器面板
const editorPanel = document.createElement('div');
editorPanel.id = 'rule-editor-panel';
editorPanel.className = 'settings-panel';
const rules = keywordGroups[group] || [];
let rulesHtml = '';
rules.forEach((rule, index) => {
rulesHtml += createRuleHtml(rule, index);
});
editorPanel.innerHTML = `
<div class="settings-header">
<h3>编辑 "${group}" 规则</h3>
<span class="settings-close" id="close-rule-editor">×</span>
</div>
<div class="rules-container" id="rules-container">
${rulesHtml}
</div>
<div class="rule-actions">
<button id="add-rule">+ 添加规则</button>
</div>
<div class="settings-actions">
<button id="cancel-rules">取消</button>
<button id="save-rules" class="save">保存规则</button>
</div>
`;
document.body.appendChild(editorPanel);
// 添加事件监听
document.getElementById('close-rule-editor').addEventListener('click', () => {
document.body.removeChild(editorPanel);
});
document.getElementById('cancel-rules').addEventListener('click', () => {
document.body.removeChild(editorPanel);
});
document.getElementById('add-rule').addEventListener('click', () => {
const container = document.getElementById('rules-container');
const newIndex = container.children.length;
const newRuleHtml = createRuleHtml({words: []}, newIndex);
const tempDiv = document.createElement('div');
tempDiv.innerHTML = newRuleHtml;
container.appendChild(tempDiv.firstElementChild);
// 添加删除规则按钮事件
document.querySelector(`.rule-item[data-index="${newIndex}"] .delete-rule`).addEventListener('click', function() {
const ruleItem = this.closest('.rule-item');
ruleItem.parentNode.removeChild(ruleItem);
});
});
document.getElementById('save-rules').addEventListener('click', () => {
saveRules(group);
document.body.removeChild(editorPanel);
});
// 添加删除规则按钮事件
document.querySelectorAll('.delete-rule').forEach(button => {
button.addEventListener('click', function() {
const ruleItem = this.closest('.rule-item');
ruleItem.parentNode.removeChild(ruleItem);
});
});
}
// 创建规则HTML
function createRuleHtml(rule, index) {
let ruleHtml = `
<div class="rule-item" data-index="${index}">
<div class="rule-header">
<span class="rule-type">规则 #${index + 1}</span>
<button class="delete-rule">删除</button>
</div>
<div class="rule-content">
`;
// 词组匹配
if (rule.words) {
const words = Array.isArray(rule.words) ? rule.words.join(', ') : '';
const minCount = rule.minCount || 1;
const maxLength = rule.maxLength || '';
ruleHtml += `
<div class="rule-option">
<label>
<input type="radio" name="rule-type-${index}" value="words" checked>
词组匹配
</label>
<div class="rule-details">
<div class="rule-field">
<label>关键词(逗号分隔):</label>
<input type="text" class="rule-words" value="${words}">
</div>
<div class="rule-field">
<label>最小匹配数:</label>
<input type="number" class="rule-min-count" value="${minCount}" min="1">
</div>
<div class="rule-field">
<label>最大内容长度:</label>
<input type="number" class="rule-max-length" value="${maxLength}" placeholder="不限">
</div>
</div>
</div>
`;
// 上下文匹配
if (rule.context) {
const context = Array.isArray(rule.context) ? rule.context.join(', ') : '';
ruleHtml += `
<div class="rule-field">
<label>上下文词(逗号分隔):</label>
<input type="text" class="rule-context" value="${context}">
</div>
`;
} else {
ruleHtml += `
<div class="rule-field">
<label>上下文词(逗号分隔):</label>
<input type="text" class="rule-context" placeholder="可选">
</div>
`;
}
}
// 精确匹配
else if (rule.exact) {
ruleHtml += `
<div class="rule-option">
<label>
<input type="radio" name="rule-type-${index}" value="exact" checked>
精确匹配
</label>
<div class="rule-details">
<div class="rule-field">
<label>精确文本:</label>
<input type="text" class="rule-exact" value="${rule.exact}">
</div>
</div>
</div>
`;
}
// 正则匹配
else if (rule.regex) {
const regexStr = rule.regex.toString();
const regexPattern = regexStr.substring(1, regexStr.lastIndexOf('/'));
const regexFlags = regexStr.substring(regexStr.lastIndexOf('/') + 1);
ruleHtml += `
<div class="rule-option">
<label>
<input type="radio" name="rule-type-${index}" value="regex" checked>
正则匹配
</label>
<div class="rule-details">
<div class="rule-field">
<label>正则表达式:</label>
<input type="text" class="rule-regex-pattern" value="${regexPattern}">
</div>
<div class="rule-field">
<label>正则标志:</label>
<input type="text" class="rule-regex-flags" value="${regexFlags}" placeholder="i">
</div>
</div>
</div>
`;
}
ruleHtml += `
</div>
</div>
`;
return ruleHtml;
}
// 保存规则
function saveRules(group) {
const ruleItems = document.querySelectorAll('.rule-item');
const newRules = [];
ruleItems.forEach(item => {
const index = item.getAttribute('data-index');
const ruleType = item.querySelector(`input[name="rule-type-${index}"]:checked`).value;
let rule = {};
if (ruleType === 'words') {
const wordsInput = item.querySelector('.rule-words').value;
const words = wordsInput.split(',').map(word => word.trim()).filter(word => word);
if (words.length > 0) {
rule.words = words;
const minCount = parseInt(item.querySelector('.rule-min-count').value);
if (!isNaN(minCount) && minCount > 0) {
rule.minCount = minCount;
}
const maxLength = parseInt(item.querySelector('.rule-max-length').value);
if (!isNaN(maxLength) && maxLength > 0) {
rule.maxLength = maxLength;
}
const contextInput = item.querySelector('.rule-context').value;
if (contextInput) {
const context = contextInput.split(',').map(ctx => ctx.trim()).filter(ctx => ctx);
if (context.length > 0) {
rule.context = context;
}
}
newRules.push(rule);
}
} else if (ruleType === 'exact') {
const exact = item.querySelector('.rule-exact').value.trim();
if (exact) {
rule.exact = exact;
newRules.push(rule);
}
} else if (ruleType === 'regex') {
const pattern = item.querySelector('.rule-regex-pattern').value.trim();
const flags = item.querySelector('.rule-regex-flags').value.trim() || 'i';
if (pattern) {
try {
rule.regex = new RegExp(pattern, flags);
newRules.push(rule);
} catch (e) {
alert(`正则表达式错误: ${e.message}`);
}
}
}
});
// 更新关键词组
keywordGroups[group] = newRules;
s
// 更新规则计数显示
const ruleCountElement = document.querySelector(`#rules-${group} .rule-count`);
if (ruleCountElement) {
ruleCountElement.textContent = `${newRules.length}条规则`;
}
// 重新应用过滤
filterPosts();
}
// 添加新分组
function addNewGroup() {
const groupName = prompt('请输入新分组名称:');
if (groupName && groupName.trim()) {
// 检查是否已存在
if (keywordGroups[groupName]) {
alert('该分组名称已存在!');
return;
}
// 添加新分组
keywordGroups[groupName] = [];
GM_setValue(`enable-${groupName}`, true);
// 重新创建设置面板
const oldPanel = document.getElementById('filter-settings-panel');
if (oldPanel) {
document.body.removeChild(oldPanel);
}
const newPanel = createSettingsPanel();
newPanel.style.display = 'block';
// 切换到分组管理标签
document.querySelector('.tab[data-tab="groups"]').click();
}
}
// 导出设置
function exportSettings() {
const settings = {
keywordGroups: keywordGroups,
filterLengthThreshold: GM_getValue('filterlengthThreshold', 20),
confidenceThreshold: GM_getValue('confidenceThreshold', 60),
hideFiltered: GM_getValue('hideFiltered', false),
enableDebug: GM_getValue('enableDebug', false),
highlightOnly: GM_getValue('highlightOnly', false)
};
// 为每个分组添加启用状态
for (const group in keywordGroups) {
settings[`enable-${group}`] = GM_getValue(`enable-${group}`, true);
}
const blob = new Blob([JSON.stringify(settings, (key, value) => {
// 特殊处理正则表达式
if (value instanceof RegExp) {
return {
__regex: true,
source: value.source,
flags: value.flags
};
}
return value;
}, 2)], {type: 'application/json'});
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'discourse-filter-settings.json';
a.click();
URL.revokeObjectURL(url);
}
// 导入设置
function importSettings() {
const input = document.createElement('input');
input.type = 'file';
input.accept = '.json';
input.onchange = function(e) {
const file = e.target.files[0];
if (!file) return;
const reader = new FileReader();
reader.onload = function(e) {
try {
const settings = JSON.parse(e.target.result, (key, value) => {
// 恢复正则表达式
if (value && value.__regex) {
return new RegExp(value.source, value.flags);
}
return value;
});
// 更新关键词组
if (settings.keywordGroups) {
Object.assign(keywordGroups, settings.keywordGroups);
}
// 更新其他设置
if (settings.filterLengthThreshold !== undefined) {
GM_setValue('filterLengthThreshold', settings.filterLengthThreshold);
}
if (settings.confidenceThreshold !== undefined) {
GM_setValue('confidenceThreshold', settings.confidenceThreshold);
}
if (settings.hideFiltered !== undefined) {
GM_setValue('hideFiltered', settings.hideFiltered);
}
if (settings.enableDebug !== undefined) {
GM_setValue('enableDebug', settings.enableDebug);
}
if (settings.highlightOnly !== undefined) {
GM_setValue('highlightOnly', settings.highlightOnly);
}
// 更新分组启用状态
for (const group in keywordGroups) {
if (settings[`enable-${group}`] !== undefined) {
GM_setValue(`enable-${group}`, settings[`enable-${group}`]);
}
}
// 重新创建设置面板
const oldPanel = document.getElementById('filter-settings-panel');
if (oldPanel) {
document.body.removeChild(oldPanel);
}
const newPanel = createSettingsPanel();
newPanel.style.display = 'block';
// 重新应用过滤
filterPosts();
alert('设置导入成功!');
} catch (error) {
alert(`导入失败: ${error.message}`);
}
};
reader.readAsText(file);
};
input.click();
}
// 保存设置
function saveSettings() {
const filterLengthThreshold = parseInt(document.getElementById('filter-length-threshold').value);
GM_setValue('filterLengthThreshold', filterLengthThreshold);
const confidenceThreshold = parseInt(document.getElementById('confidence-threshold').value);
GM_setValue('confidenceThreshold', confidenceThreshold);
// 保存分组启用状态
for (const group in keywordGroups) {
const checkbox = document.getElementById(`enable-${group}`);
if (checkbox) GM_setValue(`enable-${group}`, checkbox.checked);
}
// 保存自动隐藏设置
const autoHide = document.getElementById('auto-hide-filtered').checked;
GM_setValue('hideFiltered', autoHide);
// 保存调试模式设置
const enableDebug = document.getElementById('enable-debug')?.checked || false;
GM_setValue('enableDebug', enableDebug);
// 保存仅高亮设置
const highlightOnly = document.getElementById('highlight-only')?.checked || false;
GM_setValue('highlightOnly', highlightOnly);
// 更新过滤器面板上的切换按钮文本
const toggleButton = document.getElementById('toggle-filter');
if (toggleButton) {
toggleButton.textContent = autoHide ? '显示已过滤帖子' : '隐藏已过滤帖子';
}
// 保存自定义规则
GM_setValue("customKeywordGroups", serializeKeywordGroups(keywordGroups));
closeSettingsPanel();
filterPosts(); // 重新应用过滤
}
// 添加更多样式
GM_addStyle(`
.settings-tabs {
display: flex;
border-bottom: 1px solid #ddd;
margin-bottom: 15px;
}
.tab {
padding: 8px 15px;
cursor: pointer;
border-bottom: 2px solid transparent;
}
.tab.active {
border-bottom: 2px solid #0088cc;
font-weight: bold;
}
.rule-item {
border: 1px solid #ddd;
border-radius: 5px;
padding: 10px;
margin-bottom: 10px;
background: #f9f9f9;
}
.rule-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 10px;
}
.rule-type {
font-weight: bold;
}
.delete-rule {
background: #ff4d4d;
color: white;
border: none;
border-radius: 3px;
padding: 3px 8px;
cursor: pointer;
}
.rule-field {
margin-bottom: 8px;
}
.rule-field label {
display: block;
margin-bottom: 3px;
font-size: 12px;
color: #666;
}
.rule-field input {
width: 100%;
padding: 5px;
border: 1px solid #ddd;
border-radius: 3px;
}
.rule-actions {
margin: 15px 0;
}
#add-rule, #add-new-group {
background: #4CAF50;
color: white;
border: none;
border-radius: 3px;
padding: 5px 10px;
cursor: pointer;
}
.threshold-display {
display: flex;
align-items: center;
margin-top: 5px;
}
#length-threshold-value {
font-weight: bold;
margin-right: 10px;
}
#threshold-value {
font-weight: bold;
margin-right: 10px;
}
.threshold-description {
font-size: 12px;
color: #666;
}
.export-import {
margin-top: 15px;
}
.export-import button {
margin-right: 10px;
padding: 5px 10px;
background: #f5f5f5;
border: 1px solid #ddd;
border-radius: 3px;
cursor: pointer;
}
#rule-editor-panel {
position: fixed;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
background: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 4px 20px rgba(0,0,0,0.2);
z-index: 1001;
width: 500px;
max-height: 80vh;
overflow-y: auto;
}
.rules-container {
max-height: 400px;
overflow-y: auto;
margin-bottom: 15px;
}
.group-rules {
display: flex;
justify-content: space-between;
align-items: center;
margin-top: 5px;
}
.rule-count {
font-size: 12px;
color: #666;
}
.edit-rules {
background: #0088cc;
color: white;
border: none;
border-radius: 3px;
padding: 3px 8px;
cursor: pointer;
font-size: 12px;
}
.settings-option {
margin-bottom: 15px;
}
`);
// 打开设置面板
function openSettingsPanel() {
const panel = document.getElementById('filter-settings-panel') || createSettingsPanel();
panel.style.display = 'block';
// 加载当前设置
const filterLengthThreshold = GM_getValue('filterLengthThreshold', 20);
document.getElementById('filter-length-threshold').value = filterLengthThreshold;
document.getElementById('length-threshold-value').textContent = filterLengthThreshold;
const confidenceThreshold = GM_getValue('confidenceThreshold', 60);
document.getElementById('confidence-threshold').value = confidenceThreshold;
document.getElementById('threshold-value').textContent = confidenceThreshold;
for (const group in keywordGroups) {
const enabled = GM_getValue(`enable-${group}`, true);
const checkbox = document.getElementById(`enable-${group}`);
if (checkbox) checkbox.checked = enabled;
}
}
// 关闭设置面板
function closeSettingsPanel() {
const panel = document.getElementById('filter-settings-panel');
if (panel) panel.style.display = 'none';
}
// 重置设置
function resetSettings() {
GM_setValue('filterLengthThreshold', 20);
document.getElementById('filter-length-threshold').value = 20;
document.getElementById('length-threshold-value').value = 20;
GM_setValue('confidenceThreshold', 60);
document.getElementById('confidence-threshold').value = 60;
document.getElementById('threshold-value').textContent = 60;
// 重新加载默认配置
keywordGroups = deserializeKeywordGroups(GM_getValue("defaultKeywordGroups", DEFAULT_KEYWORD_GROUPS));
for (const group in keywordGroups) {
GM_setValue(`enable-${group}`, true);
const checkbox = document.getElementById(`enable-${group}`);
if (checkbox) checkbox.checked = true;
}
// 重新创建设置面板
const oldPanel = document.getElementById('filter-settings-panel');
if (oldPanel) {
document.body.removeChild(oldPanel);
}
const newPanel = createSettingsPanel();
newPanel.style.display = 'block';
// 立即应用新规则
filterPosts();
}
// 更新过滤统计
function updateFilterStats(stats) {
const container = document.getElementById('filter-groups');
if (!container) return;
container.innerHTML = '';
for (const group in stats) {
if (stats[group] > 0) {
const groupDiv = document.createElement('div');
groupDiv.className = 'filter-group';
groupDiv.innerHTML = `
<span class="filter-name">${group}:</span>
<span class="filter-count">${stats[group]}</span>
`;
container.appendChild(groupDiv);
}
}
// 添加总计
const total = Object.values(stats).reduce((sum, count) => sum + count, 0);
if (total > 0) {
const totalDiv = document.createElement('div');
totalDiv.className = 'filter-group';
totalDiv.innerHTML = `
<span class="filter-name"><strong>总计:</strong></span>
<span class="filter-count">${total}</span>
`;
container.appendChild(totalDiv);
}
}
// 检查帖子是否包含关键词 - 改进的匹配逻辑
function checkPostForKeywords(post) {
const postContent = post.querySelector('.cooked')?.textContent || '';
const postContentLower = postContent.toLowerCase();
const stats = {};
const confidenceThreshold = GM_getValue('confidenceThreshold', 60);
const filterLengthThreshold = GM_getValue('filterLengthThreshold', 20);
// 移除之前的过滤标记
post.classList.remove('filtered-post', 'confidence-high', 'confidence-medium', 'confidence-low');
post.removeAttribute('data-filter-reason');
for (const group in keywordGroups) {
// 检查该组是否启用
if (!GM_getValue(`enable-${group}`, true)) {
stats[group] = 0;
continue;
}
stats[group] = 0;
let maxConfidence = 0;
let matchReason = '';
// 遍历该组的所有匹配规则
for (const rule of keywordGroups[group]) {
let confidence = 0;
let matched = false;
// 1. 精确匹配
if (rule.exact && postContentLower === (rule.exact.toLowerCase())) {
confidence = 95;
matched = true;
matchReason = `精确匹配: "${rule.exact}"`;
}
// 2. 正则匹配
else if (rule.regex && rule.regex.test(postContent)) {
confidence = 90;
matched = true;
matchReason = `正则匹配: ${rule.regex.toString()}`;
}
// 3. 词组匹配
else if (rule.words) {
// 计算匹配的词数
const matchedWords = rule.words.filter(word =>
postContentLower.includes(word.toLowerCase())
);
// 检查是否达到最小匹配数
const minCount = rule.minCount || 1;
if (matchedWords.length >= minCount) {
matched = true;
// 基础置信度: 匹配词数/总词数的比例
confidence = (matchedWords.length / rule.words.length) * 70;
// 上下文匹配加分
if (rule.context) {
const contextMatches = rule.context.filter(ctx =>
postContentLower.includes(ctx.toLowerCase())
);
if (contextMatches.length > 0) {
confidence += 20 * (contextMatches.length / rule.context.length);
} else {
confidence -= 30; // 没有上下文匹配则降低置信度
}
}
// 内容长度检查
if (rule.maxLength && postContent.length <= rule.maxLength) {
confidence += 10;
} else if (rule.maxLength) {
// 内容长度超过设定值时动态扣除置信度
const lengthRatio = postContent.length / rule.maxLength;
if (lengthRatio > 5) {
// 内容长度过长时，直接将置信度置为0
confidence = 0;
} else if (lengthRatio > 2) {
// 根据长度比例动态扣除置信度，长度越长扣除越多
confidence -= Math.min(50, 20 * (lengthRatio - 1));
}
}
matchReason = `匹配词: ${matchedWords.join(', ')}`;
}
}
// 更新最高置信度
if (matched && confidence > maxConfidence) {
maxConfidence = confidence;
stats[group] = 1;
}
}
// 修改，如果置信度超过阈值且长度低于阈值，标记为过滤
if (maxConfidence >= confidenceThreshold && postContent.length < filterLengthThreshold) {
post.classList.add('filtered-post');
post.setAttribute('data-filter-reason', `${group} (${Math.round(maxConfidence)}%): ${matchReason}`);
// 根据置信度添加不同的样式
if (maxConfidence >= 85) {
post.classList.add('confidence-high');
} else if (maxConfidence >= 70) {
post.classList.add('confidence-medium');
} else {
post.classList.add('confidence-low');
}
break; // 一个帖子只归类到一个组
}
}
return stats;
}
// 过滤帖子并统计
// 更新过滤帖子函数，支持新的设置
function filterPosts() {
// 查找所有可能的帖子容器
const postContainers = [
...document.querySelectorAll('.topic-post'), // 帖子详情页
...document.querySelectorAll('.topic-list-item'), // 帖子列表页
...document.querySelectorAll('[id^="ember"] .topic-post') // SPA 动态加载的帖子
];
const stats = {};
// 初始化统计对象
for (const group in keywordGroups) {
stats[group] = 0;
}
// 调试信息
const debugPanel = document.getElementById('filter-debug');
const enableDebug = GM_getValue('enableDebug', false);
if (debugPanel) {
debugPanel.textContent = `找到 ${postContainers.length} 个帖子容器`;
debugPanel.style.display = (postContainers.length > 0 && enableDebug) ? 'block' : 'none';
// 5秒后隐藏调试信息
if (enableDebug) {
setTimeout(() => {
debugPanel.style.display = 'none';
}, 5000);
}
}
postContainers.forEach(post => {
const postStats = checkPostForKeywords(post);
for (const group in postStats) {
stats[group] += postStats[group];
}
});
updateFilterStats(stats);
// 应用当前的隐藏/显示状态
applyFilterVisibility();
}
// 更新应用过滤可见性函数，支持仅高亮模式
function applyFilterVisibility() {
const hideFiltered = GM_getValue('hideFiltered', false);
const highlightOnly = GM_getValue('highlightOnly', false);
const filteredPosts = document.querySelectorAll('.filtered-post');
filteredPosts.forEach(post => {
if (hideFiltered && !highlightOnly) {
post.classList.add('hidden');
} else {
post.classList.remove('hidden');
}
});
}
// 监听 URL 变化
function observeUrlChanges() {
let lastUrl = location.href;
// 创建一个新的 MutationObserver 实例
const observer = new MutationObserver(() => {
if (lastUrl !== location.href) {
lastUrl = location.href;
console.log('URL changed to:', lastUrl);
// 延迟执行，等待 SPA 内容加载
setTimeout(() => {
filterPosts();
setupPostStreamObserver();
}, 1000);
}
});
// 开始观察 document.body 的变化
observer.observe(document.body, { childList: true, subtree: true });
}
// 监听帖子流的变化
function setupPostStreamObserver() {
// 查找可能的帖子容器
const postStreams = [
document.querySelector('.post-stream'),
document.querySelector('.topic-list'),
...document.querySelectorAll('[id^="ember"] .post-stream')
].filter(el => el !== null);
if (postStreams.length === 0) return;
// 为每个容器创建观察器
postStreams.forEach(container => {
const observer = new MutationObserver(mutations => {
let shouldFilter = false;
mutations.forEach(mutation => {
if (mutation.addedNodes.length) {
mutation.addedNodes.forEach(node => {
if (node.nodeType === 1 && (
node.classList?.contains('topic-post') ||
node.classList?.contains('topic-list-item') ||
node.querySelector?.('.topic-post')
)) {
shouldFilter = true;
}
});
}
});
if (shouldFilter) {
filterPosts();
}
});
observer.observe(container, {
childList: true,
subtree: true
});
});
}
// 监听 DOM 变化，处理 SPA 动态加载的内容
function observeDomChanges() {
const observer = new MutationObserver(mutations => {
let newEmberContainers = false;
let newPostsAdded = false;
mutations.forEach(mutation => {
if (mutation.addedNodes.length) {
mutation.addedNodes.forEach(node => {
if (node.nodeType === 1) {
// 检查是否是 Ember 容器
if (node.id && node.id.startsWith('ember')) {
newEmberContainers = true;
}
// 检查是否包含帖子
if (node.classList?.contains('topic-post') ||
node.classList?.contains('topic-list-item') ||
node.querySelector?.('.topic-post, .topic-list-item')) {
newPostsAdded = true;
}
}
});
}
});
if (newEmberContainers || newPostsAdded) {
// 延迟执行，等待内容完全加载
setTimeout(() => {
filterPosts();
setupPostStreamObserver();
}, 500);
}
});
// 观察 #main-outlet 和整个 body
const mainOutlet = document.getElementById('main-outlet');
if (mainOutlet) {
observer.observe(mainOutlet, { childList: true, subtree: true });
} else {
observer.observe(document.body, { childList: true, subtree: true });
}
}
// 初始化
function init() {
// 等待页面完全加载
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', onReady);
} else {
onReady();
}
function onReady() {
// 初始化规则
const savedData = GM_getValue('customKeywordGroups');
if (savedData) {
keywordGroups = deserializeKeywordGroups(savedData);
}
// 初始化设置
if (GM_getValue('filterLengthThreshold') === undefined) {
GM_setValue('filterLengthThreshold', 20);
}
if (GM_getValue('confidenceThreshold') === undefined) {
GM_setValue('confidenceThreshold', 60);
for (const group in keywordGroups) {
GM_setValue(`enable-${group}`, true);
}
}
// 初始化隐藏状态设置（如果未设置）
if (GM_getValue('hideFiltered') === undefined) {
GM_setValue('hideFiltered', false);
}
createFilterStatsPanel();
// 初始过滤
setTimeout(() => {
filterPosts();
}, 1000);
// 设置各种观察器
observeUrlChanges();
setupPostStreamObserver();
observeDomChanges();
// 添加页面可见性变化监听
document.addEventListener('visibilitychange', () => {
if (!document.hidden) {
// 页面重新变为可见时，重新过滤
setTimeout(() => {
filterPosts();
}, 500);
}
});
// 恢复面板位置，by snowsoul
const panel = document.getElementById('filter-stats');
if (panel) {
const savedPosition = GM_getValue('panelPosition', null);
if (savedPosition) {
panel.style.left = savedPosition.x;
panel.style.top = savedPosition.y;
panel.style.right = 'unset'; // 取消原有的right定位
}
}
}
}
init();
})();