昨天我花了点时间使用 cursor 写了一个简单的增强本地图谱的代码片段，也给大家分享一下
主要实现了两个功能：
- 本地图谱支持深度
- 出链也会计算权重
效果
代码片段关闭：
代码片段开启：
这个片段可以用来干什么
- 一个用于快速跳转的路径地图（这个用处最大了，文档树、搜索、反链面板都去一边吧）
- 打开一个文档，就可以通过关系图谱快速记起相关联项目的结构
本来还编了很多的，想了想还是删了。
代码
(function() {
// 预设配置 - 可根据需要调整
const 预设配置 = {
默认: {
最大深度: 4, // 建议3-4层深度对大多数情况已足够
每层最大节点数: 25, // 每层处理的最大节点数
并发请求数: 8, // 同时发送的最大请求数
请求间隔: 0, // 请求间隔(毫秒)，0表示不延迟
最大处理总数: 120 // 处理节点上限
},
高速: {
最大深度: 4, // 限制深度提高响应速度
每层最大节点数: 15, // 减少每层节点数加快处理
并发请求数: 15, // 大幅提高并发
请求间隔: 0, // 无延迟
最大处理总数: 100 // 减少处理总数提高速度
},
全面: {
最大深度: 5, // 增加深度获取更多关联
每层最大节点数: 30, // 增加每层节点数获取更全面信息
并发请求数: 6, // 降低并发减轻服务器压力
请求间隔: 50, // 添加少量延迟
最大处理总数: 150 // 处理更多节点
}
};
// 当前使用的配置（默认使用"高速"配置）
const 当前模式 = "高速";
// 运行配置
const 配置 = {
...预设配置[当前模式],
已处理节点: new Set(), // 已处理节点集合
已请求节点: new Set(), // 已请求节点集合
正在处理: false, // 处理标记
显示调试信息: true, // 是否显示调试信息
节点缓存: new Map(), // 节点请求结果缓存
处理计数: 0, // 处理计数器
双向调整权重: true, // 是否为引用和被引用节点都调整大小
默认节点大小: 15, // 默认节点大小
引用权重系数: 1.0, // 引用其他节点时的权重系数
被引用权重系数: 1.2, // 被引用节点时的权重系数（略高于引用权重）
使用线性计算: true, // 使用线性计算而非对数计算
大小增长系数: 0.7, // 节点大小增长系数(值越大，差异越明显)
尺寸上限倍数: 5.0, // 节点最大尺寸为默认尺寸的倍数
强化对比度: true, // 进一步强化节点大小差异
基础增长倍数: 1.5 // 即使只有1个引用也会有的基础增长
};
// 保存原始fetch函数
const 原始Fetch = window.fetch;
// 拦截fetch请求
window.fetch = async function(...args) {
const url = args[0];
// 只拦截关系图请求
if (typeof url === 'string' && url.includes('/api/graph/getLocalGraph')) {
// 避免递归处理
if (配置.正在处理) {
return 原始Fetch.apply(this, args);
}
try {
配置.正在处理 = true;
// 获取基础数据
const 响应 = await 原始Fetch.apply(this, args);
const 响应克隆 = 响应.clone();
const 原始数据 = await 响应克隆.json();
// 获取当前文档ID
const 请求体 = JSON.parse(args[1].body);
const 根节点ID = 请求体.id;
// 重置状态
配置.已处理节点.clear();
配置.已请求节点.clear();
配置.节点缓存.clear();
配置.处理计数 = 0;
if (配置.显示调试信息) {
console.log(`[图谱增强${当前模式}] 开始处理根节点`);
console.time('图谱处理用时');
}
// 初始化根节点
配置.已处理节点.add(根节点ID);
配置.已请求节点.add(根节点ID);
配置.处理计数++;
// 准备数据结构 - 直接使用Map提高查找效率
const 节点映射 = new Map(原始数据.data.nodes.map(节点 => [节点.id, 节点]));
const 连线映射 = new Map();
// 引用计数器 - 记录每个节点的引用和被引用次数
const 引用计数 = new Map();
// 初始化引用计数
for (const 节点 of 原始数据.data.nodes) {
引用计数.set(节点.id, { 引用数: 0, 被引用数: 0 });
}
// 记录连线 - 使用Set加速
const 连线集合 = new Set();
原始数据.data.links.forEach(连线 => {
const 连线键 = `${连线.from}-${连线.to}`;
连线映射.set(连线键, 连线);
连线集合.add(连线键);
// 更新引用计数
if (引用计数.has(连线.from)) {
const 计数 = 引用计数.get(连线.from);
计数.引用数 += 1;
引用计数.set(连线.from, 计数);
}
if (引用计数.has(连线.to)) {
const 计数 = 引用计数.get(连线.to);
计数.被引用数 += 1;
引用计数.set(连线.to, 计数);
}
});
// 快速找出初始关联节点
const 初始关联节点 = [];
for (const 连线 of 原始数据.data.links) {
const 相关节点 = 连线.from === 根节点ID ? 连线.to :
连线.to === 根节点ID ? 连线.from : null;
if (相关节点 && !配置.已请求节点.has(相关节点)) {
初始关联节点.push(相关节点);
配置.已请求节点.add(相关节点);
}
}
// 高性能处理所有层级
await 高速处理(初始关联节点, 节点映射, 连线映射, 连线集合, 引用计数, 请求体.conf);
// 计算最终节点大小
if (配置.双向调整权重) {
重新计算节点大小(节点映射, 引用计数);
}
if (配置.显示调试信息) {
console.timeEnd('图谱处理用时');
console.log(`[图谱增强${当前模式}] 完成: ${节点映射.size}节点, ${连线映射.size}连接, 处理${配置.处理计数}节点`);
}
// 构建新响应
const 新数据 = {
...原始数据,
data: {
...原始数据.data,
nodes: Array.from(节点映射.values()),
links: Array.from(连线映射.values())
}
};
return new Response(JSON.stringify(新数据), {
status: 响应.status,
statusText: 响应.statusText,
headers: 响应.headers
});
} finally {
配置.正在处理 = false;
}
}
return 原始Fetch.apply(this, args);
};
/**
* 从连线中提取相关节点
*/
function 获取关联节点(节点ID, 连线数组, 已访问集合) {
const 关联节点 = [];
for (const 连线 of 连线数组) {
if (连线.from === 节点ID && !已访问集合.has(连线.to)) {
关联节点.push(连线.to);
} else if (连线.to === 节点ID && !已访问集合.has(连线.from)) {
关联节点.push(连线.from);
}
}
return 关联节点;
}
/**
* 高性能处理所有层级节点
*/
async function 高速处理(初始节点集, 节点映射, 连线映射, 连线集合, 引用计数, 图谱配置) {
let 当前深度 = 1;
let 当前层节点 = [...初始节点集];
// 非递归批量处理多层节点
while (
当前深度 < 配置.最大深度 &&
当前层节点.length > 0 &&
配置.处理计数 < 配置.最大处理总数
) {
if (配置.显示调试信息) {
console.log(`[图谱增强${当前模式}] 处理第${当前深度}层: ${当前层节点.length}个节点, 已处理${配置.处理计数}个`);
}
// 限制本层处理量
const 本层节点 = 当前层节点.slice(0, 配置.每层最大节点数);
const 下一层节点集 = new Set();
// 高并发批处理
for (let i = 0; i < 本层节点.length; i += 配置.并发请求数) {
// 分批处理，每批并发请求
const 批次节点 = 本层节点.slice(i, i + 配置.并发请求数);
// 并行处理当前批次
const 批处理结果 = await Promise.all(
批次节点.map(async (节点ID) => {
// 跳过已处理
if (配置.已处理节点.has(节点ID) || 配置.处理计数 >= 配置.最大处理总数) {
return null;
}
try {
// 标记处理
配置.已处理节点.add(节点ID);
配置.处理计数++;
// 优先使用缓存
if (配置.节点缓存.has(节点ID)) {
return 配置.节点缓存.get(节点ID);
}
// 发送请求
const 请求数据 = {
type: "local",
k: "",
id: 节点ID,
conf: 图谱配置
};
const 响应 = await fetch('/api/graph/getLocalGraph', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(请求数据)
});
const 响应数据 = await 响应.json();
// 处理数据
if (响应数据?.code === 0 && 响应数据.data) {
// 提取下一级关联节点
const 相关节点 = [];
// 快速合并节点
for (const 节点 of 响应数据.data.nodes) {
if (!节点映射.has(节点.id)) {
节点映射.set(节点.id, 节点);
// 初始化引用计数
if (!引用计数.has(节点.id)) {
引用计数.set(节点.id, { 引用数: 0, 被引用数: 0 });
}
}
}
// 快速合并连线并收集关联节点
for (const 连线 of 响应数据.data.links) {
const 连线键 = `${连线.from}-${连线.to}`;
if (!连线集合.has(连线键)) {
连线集合.add(连线键);
连线映射.set(连线键, 连线);
// 更新引用计数
if (引用计数.has(连线.from)) {
const 计数 = 引用计数.get(连线.from);
计数.引用数 += 1;
引用计数.set(连线.from, 计数);
} else {
引用计数.set(连线.from, { 引用数: 1, 被引用数: 0 });
}
if (引用计数.has(连线.to)) {
const 计数 = 引用计数.get(连线.to);
计数.被引用数 += 1;
引用计数.set(连线.to, 计数);
} else {
引用计数.set(连线.to, { 引用数: 0, 被引用数: 1 });
}
// 提取关联节点
const 目标节点 = 连线.from === 节点ID ? 连线.to :
连线.to === 节点ID ? 连线.from : null;
if (目标节点 && !配置.已请求节点.has(目标节点)) {
相关节点.push(目标节点);
配置.已请求节点.add(目标节点);
}
}
}
// 缓存结果
配置.节点缓存.set(节点ID, 相关节点);
return 相关节点;
}
return null;
} catch (错误) {
return null;
}
})
);
// 合并到下一层
for (const 结果 of 批处理结果) {
if (结果 && Array.isArray(结果)) {
结果.forEach(id => 下一层节点集.add(id));
}
}
// 批次间可选延迟
if (配置.请求间隔 > 0 && i + 配置.并发请求数 < 本层节点.length) {
await new Promise(resolve => setTimeout(resolve, 配置.请求间隔));
}
}
// 准备下一层
当前层节点 = Array.from(下一层节点集);
当前深度++;
}
}
/**
* 重新计算节点大小，同时考虑引用和被引用因素，使用更合理的计算方式
* 增强节点大小差异，使重要节点更加突出
*/
function 重新计算节点大小(节点映射, 引用计数) {
// 找出最大的引用数和被引用数，用于归一化
let 最大引用数 = 1;
let 最大被引用数 = 1;
for (const 计数 of 引用计数.values()) {
最大引用数 = Math.max(最大引用数, 计数.引用数);
最大被引用数 = Math.max(最大被引用数, 计数.被引用数);
}
// 防止除零
最大引用数 = Math.max(1, 最大引用数);
最大被引用数 = Math.max(1, 最大被引用数);
for (const [节点ID, 节点对象] of 节点映射.entries()) {
if (引用计数.has(节点ID)) {
const 计数 = 引用计数.get(节点ID);
let 引用得分, 被引用得分;
if (配置.使用线性计算) {
// 线性计算得分 - 更公平地表示引用数量
引用得分 = (计数.引用数 / 最大引用数) * 配置.引用权重系数;
被引用得分 = (计数.被引用数 / 最大被引用数) * 配置.被引用权重系数;
// 强化对比度 - 让即使很少引用的节点也有明显变化
if (配置.强化对比度 && (计数.引用数 > 0 || 计数.被引用数 > 0)) {
引用得分 = 配置.基础增长倍数 * 引用得分 / (引用得分 + 0.3);
被引用得分 = 配置.基础增长倍数 * 被引用得分 / (被引用得分 + 0.3);
}
} else {
// 对数计算得分 - 平滑处理引用数较多的情况
引用得分 = Math.log2(计数.引用数 + 1) / Math.log2(最大引用数 + 1) * 配置.引用权重系数;
被引用得分 = Math.log2(计数.被引用数 + 1) / Math.log2(最大被引用数 + 1) * 配置.被引用权重系数;
}
// 合并得分，计算最终尺寸
const 总得分 = 引用得分 + 被引用得分;
// 使用更激进的计算方式增大差异
let 尺寸系数;
if (配置.强化对比度) {
// 指数增长模式，让差异更明显
尺寸系数 = Math.pow(1 + 总得分, 配置.大小增长系数 * 2);
} else {
// 缩放到合理范围内
尺寸系数 = 1 + (总得分 * 配置.大小增长系数 * 配置.尺寸上限倍数);
}
// 限制最大尺寸
const 最终系数 = Math.min(尺寸系数, 配置.尺寸上限倍数);
// 应用新尺寸
节点对象.size = 配置.默认节点大小 * 最终系数;
// 添加引用和被引用数据便于调试
节点对象.refs = 计数.引用数;
节点对象.defs = 计数.被引用数;
// 如果是调试模式，为节点添加权重信息
if (配置.显示调试信息 && (计数.引用数 > 0 || 计数.被引用数 > 0)) {
const 原标签 = 节点对象.label;
节点对象.title = `${原标签}\n引用: ${计数.引用数}, 被引用: ${计数.被引用数}`;
}
}
}
}
// 显示已启用通知
console.log(`[图谱深度增强] 已启用${当前模式}模式: 深度${配置.最大深度}, 节点上限${配置.最大处理总数}, 强化对比${配置.强化对比度}`);
// 添加样式
const 样式 = document.createElement('style');
样式.textContent = `
.graph-depth-notification {
position: fixed;
bottom: 20px;
right: 20px;
background-color: rgba(0, 0, 0, 0.75);
color: white;
padding: 12px 16px;
border-radius: 6px;
z-index: 9999;
font-size: 14px;
transition: opacity 0.5s;
opacity: 1;
}
.graph-depth-notification.fade {
opacity: 0;
}
`;
document.head.appendChild(样式);
// 创建通知
const 通知 = document.createElement('div');
通知.className = 'graph-depth-notification';
通知.textContent = `思源笔记关系图谱深度增强已启用 (${当前模式}模式, 强化节点差异)`;
document.body.appendChild(通知);
setTimeout(() => {
通知.classList.add('fade');
setTimeout(() => 通知.remove(), 500);
}, 3000);
})();
再放个不会修改节点权重的旧版本
(function() {
// 预设配置 - 可根据需要调整
const 预设配置 = {
默认: {
最大深度: 4, // 建议3-4层深度对大多数情况已足够
每层最大节点数: 25, // 每层处理的最大节点数
并发请求数: 8, // 同时发送的最大请求数
请求间隔: 0, // 请求间隔(毫秒)，0表示不延迟
最大处理总数: 120 // 处理节点上限
},
高速: {
最大深度: 4, // 限制深度提高响应速度
每层最大节点数: 15, // 减少每层节点数加快处理
并发请求数: 15, // 大幅提高并发
请求间隔: 0, // 无延迟
最大处理总数: 100 // 减少处理总数提高速度
},
全面: {
最大深度: 5, // 增加深度获取更多关联
每层最大节点数: 30, // 增加每层节点数获取更全面信息
并发请求数: 6, // 降低并发减轻服务器压力
请求间隔: 50, // 添加少量延迟
最大处理总数: 150 // 处理更多节点
}
};
// 当前使用的配置（默认使用"高速"配置）
const 当前模式 = "高速";
// 运行配置
const 配置 = {
...预设配置[当前模式],
已处理节点: new Set(), // 已处理节点集合
已请求节点: new Set(), // 已请求节点集合
正在处理: false, // 处理标记
显示调试信息: true, // 是否显示调试信息
节点缓存: new Map(), // 节点请求结果缓存
处理计数: 0 // 处理计数器
};
// 保存原始fetch函数
const 原始Fetch = window.fetch;
// 拦截fetch请求
window.fetch = async function(...args) {
const url = args[0];
// 只拦截关系图请求
if (typeof url === 'string' && url.includes('/api/graph/getLocalGraph')) {
// 避免递归处理
if (配置.正在处理) {
return 原始Fetch.apply(this, args);
}
try {
配置.正在处理 = true;
// 获取基础数据
const 响应 = await 原始Fetch.apply(this, args);
const 响应克隆 = 响应.clone();
const 原始数据 = await 响应克隆.json();
// 获取当前文档ID
const 请求体 = JSON.parse(args[1].body);
const 根节点ID = 请求体.id;
// 重置状态
配置.已处理节点.clear();
配置.已请求节点.clear();
配置.节点缓存.clear();
配置.处理计数 = 0;
if (配置.显示调试信息) {
console.log(`[图谱增强${当前模式}] 开始处理根节点`);
console.time('图谱处理用时');
}
// 初始化根节点
配置.已处理节点.add(根节点ID);
配置.已请求节点.add(根节点ID);
配置.处理计数++;
// 准备数据结构 - 直接使用Map提高查找效率
const 节点映射 = new Map(原始数据.data.nodes.map(节点 => [节点.id, 节点]));
const 连线映射 = new Map();
// 记录连线 - 使用Set加速
const 连线集合 = new Set();
原始数据.data.links.forEach(连线 => {
const 连线键 = `${连线.from}-${连线.to}`;
连线映射.set(连线键, 连线);
连线集合.add(连线键);
});
// 快速找出初始关联节点
const 初始关联节点 = [];
for (const 连线 of 原始数据.data.links) {
const 相关节点 = 连线.from === 根节点ID ? 连线.to :
连线.to === 根节点ID ? 连线.from : null;
if (相关节点 && !配置.已请求节点.has(相关节点)) {
初始关联节点.push(相关节点);
配置.已请求节点.add(相关节点);
}
}
// 高性能处理所有层级
await 高速处理(初始关联节点, 节点映射, 连线映射, 连线集合, 请求体.conf);
if (配置.显示调试信息) {
console.timeEnd('图谱处理用时');
console.log(`[图谱增强${当前模式}] 完成: ${节点映射.size}节点, ${连线映射.size}连接, 处理${配置.处理计数}节点`);
}
// 构建新响应
const 新数据 = {
...原始数据,
data: {
...原始数据.data,
nodes: Array.from(节点映射.values()),
links: Array.from(连线映射.values())
}
};
return new Response(JSON.stringify(新数据), {
status: 响应.status,
statusText: 响应.statusText,
headers: 响应.headers
});
} finally {
配置.正在处理 = false;
}
}
return 原始Fetch.apply(this, args);
};
/**
* 从连线中提取相关节点
*/
function 获取关联节点(节点ID, 连线数组, 已访问集合) {
const 关联节点 = [];
for (const 连线 of 连线数组) {
if (连线.from === 节点ID && !已访问集合.has(连线.to)) {
关联节点.push(连线.to);
} else if (连线.to === 节点ID && !已访问集合.has(连线.from)) {
关联节点.push(连线.from);
}
}
return 关联节点;
}
/**
* 高性能处理所有层级节点
*/
async function 高速处理(初始节点集, 节点映射, 连线映射, 连线集合, 图谱配置) {
let 当前深度 = 1;
let 当前层节点 = [...初始节点集];
// 非递归批量处理多层节点
while (
当前深度 < 配置.最大深度 &&
当前层节点.length > 0 &&
配置.处理计数 < 配置.最大处理总数
) {
if (配置.显示调试信息) {
console.log(`[图谱增强${当前模式}] 处理第${当前深度}层: ${当前层节点.length}个节点, 已处理${配置.处理计数}个`);
}
// 限制本层处理量
const 本层节点 = 当前层节点.slice(0, 配置.每层最大节点数);
const 下一层节点集 = new Set();
// 高并发批处理
for (let i = 0; i < 本层节点.length; i += 配置.并发请求数) {
// 分批处理，每批并发请求
const 批次节点 = 本层节点.slice(i, i + 配置.并发请求数);
// 并行处理当前批次
const 批处理结果 = await Promise.all(
批次节点.map(async (节点ID) => {
// 跳过已处理
if (配置.已处理节点.has(节点ID) || 配置.处理计数 >= 配置.最大处理总数) {
return null;
}
try {
// 标记处理
配置.已处理节点.add(节点ID);
配置.处理计数++;
// 优先使用缓存
if (配置.节点缓存.has(节点ID)) {
return 配置.节点缓存.get(节点ID);
}
// 发送请求
const 请求数据 = {
type: "local",
k: "",
id: 节点ID,
conf: 图谱配置
};
const 响应 = await fetch('/api/graph/getLocalGraph', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(请求数据)
});
const 响应数据 = await 响应.json();
// 处理数据
if (响应数据?.code === 0 && 响应数据.data) {
// 提取下一级关联节点
const 相关节点 = [];
// 快速合并节点
for (const 节点 of 响应数据.data.nodes) {
if (!节点映射.has(节点.id)) {
节点映射.set(节点.id, 节点);
}
}
// 快速合并连线并收集关联节点
for (const 连线 of 响应数据.data.links) {
const 连线键 = `${连线.from}-${连线.to}`;
if (!连线集合.has(连线键)) {
连线集合.add(连线键);
连线映射.set(连线键, 连线);
// 提取关联节点
const 目标节点 = 连线.from === 节点ID ? 连线.to :
连线.to === 节点ID ? 连线.from : null;
if (目标节点 && !配置.已请求节点.has(目标节点)) {
相关节点.push(目标节点);
配置.已请求节点.add(目标节点);
}
}
}
// 缓存结果
配置.节点缓存.set(节点ID, 相关节点);
return 相关节点;
}
return null;
} catch (错误) {
return null;
}
})
);
// 合并到下一层
for (const 结果 of 批处理结果) {
if (结果 && Array.isArray(结果)) {
结果.forEach(id => 下一层节点集.add(id));
}
}
// 批次间可选延迟
if (配置.请求间隔 > 0 && i + 配置.并发请求数 < 本层节点.length) {
await new Promise(resolve => setTimeout(resolve, 配置.请求间隔));
}
}
// 准备下一层
当前层节点 = Array.from(下一层节点集);
当前深度++;
}
}
// 显示已启用通知
console.log(`[图谱深度增强] 已启用${当前模式}模式: 深度${配置.最大深度}, 并发${配置.并发请求数}, 节点上限${配置.最大处理总数}`);
// 添加样式
const 样式 = document.createElement('style');
样式.textContent = `
.graph-depth-notification {
position: fixed;
bottom: 20px;
right: 20px;
background-color: rgba(0, 0, 0, 0.75);
color: white;
padding: 12px 16px;
border-radius: 6px;
z-index: 9999;
font-size: 14px;
transition: opacity 0.5s;
opacity: 1;
}
.graph-depth-notification.fade {
opacity: 0;
}
`;
document.head.appendChild(样式);
// 创建通知
const 通知 = document.createElement('div');
通知.className = 'graph-depth-notification';
通知.textContent = `思源笔记关系图谱深度增强已启用 (${当前模式}模式)`;
document.body.appendChild(通知);
setTimeout(() => {
通知.classList.add('fade');
setTimeout(() => 通知.remove(), 500);
}, 3000);
})();
欢迎来到这里！
我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。
注册 关于