Trilium Notes自动化脚本开发：从效率痛点到流程重构的实践指南

2026-04-07 12:05:50作者：宗隆裙

问题发现：知识管理中的效率瓶颈

在现代知识工作中，信息处理的效率直接决定了知识创造的速度。 Trilium Notes作为一款强大的个人知识库工具，虽然提供了丰富的手动操作功能，但在面对重复性任务和复杂知识处理场景时，仍存在显著效率瓶颈。

典型场景的效率痛点

高频重复操作困境

知识工作者平均每天需要执行20-30次相似的笔记整理操作，包括：

会议记录的结构化处理
网页内容的规范化保存
跨笔记的信息关联维护
定期数据备份与整理

这些操作不仅占用大量时间，还容易因人为疏忽导致信息遗漏或格式不一致。

知识关联的人工依赖

传统笔记管理中，建立知识间的关联完全依赖用户手动操作：

新笔记创建后需手动添加相关标签
跨笔记引用需要记忆或搜索
知识体系的构建缺乏自动化支持

这种依赖人工的方式严重制约了知识网络的形成速度和完整性。

数据处理的时间成本

在处理大量笔记数据时，手动操作面临巨大挑战：

批量修改格式需逐个处理
复杂条件筛选需多次搜索
统计分析需人工汇总数据

这些任务往往耗费数小时，却只产生有限价值。

方案设计：Trilium脚本架构与核心能力

针对上述痛点，Trilium提供了强大的脚本编程能力，通过前后端两套API体系，实现知识管理流程的自动化与智能化。

脚本系统架构设计

Trilium的脚本系统采用分层架构设计，主要包含以下核心组件：

[用户脚本] → [脚本执行环境] → [API抽象层] → [核心服务层] → [数据存储层]

用户脚本：用户编写的业务逻辑代码，分为前端和后端两种类型
脚本执行环境：提供安全的沙箱环境，隔离不同脚本的执行
API抽象层：封装核心功能为易用接口，如BackendScriptApi和FrontendScriptApi
核心服务层：实现笔记操作、搜索、渲染等核心功能
数据存储层：管理笔记数据的持久化存储

这种架构既保证了脚本开发的便捷性，又确保了系统的安全性和稳定性。

核心API能力矩阵

Trilium提供了全面的API能力，可分为以下几大类别：

后端API核心能力

笔记操作：创建、读取、更新、删除笔记及属性
搜索功能：基于Trilium查询语法的高级搜索
事务管理：确保批量操作的原子性
文件处理：导入导出、附件管理
系统集成：定时任务、事件监听

后端API实现位于[src/services/backend_script_api.js]，提供了直接操作数据库的能力，适合处理数据密集型任务。

前端API核心能力

UI交互：消息提示、对话框、菜单扩展
界面控制：笔记激活、面板管理、视图切换
用户输入：快捷键、表单处理、拖拽操作
组件开发：自定义小部件、工具栏扩展

前端API文档可参考[docs/frontend_api/FrontendScriptApi.html]，专注于用户界面交互和体验增强。

脚本开发环境搭建

开始Trilium脚本开发前，需要完成以下准备工作：

创建类型为"code"的笔记
设置MIME类型为"application/javascript"
添加属性指定运行环境：
- #run=backend：后端脚本，拥有数据操作权限
- #run=frontend：前端脚本，专注UI交互
点击笔记工具栏中的运行按钮执行脚本

⚠️ 注意：后端脚本拥有直接操作数据库的权限，请在开发时做好数据备份，避免误操作导致数据丢失。

实现步骤：从基础到进阶的自动化案例

案例一：研究文献自动处理系统（基础版）

场景描述

研究人员经常需要从PDF文献中提取关键信息并整理为结构化笔记。手动处理单篇文献平均需要15分钟，而每周可能需要处理10-20篇文献，耗费大量时间。

核心代码实现

// == 研究文献自动处理脚本 ==
// 1. 配置参数
const LITERATURE_FOLDER_ID = "literature-reviews"; // 文献笔记存放目录ID
const PROCESSED_TAG = "status:processed";          // 已处理标记
const UNPROCESSED_TAG = "status:unprocessed";      // 待处理标记

// 2. 搜索待处理文献笔记
const unprocessedNotes = api.searchForNotes(`#${UNPROCESSED_TAG}`);

if (unprocessedNotes.length === 0) {
  api.showMessage("没有待处理的文献笔记", "info");
  return;
}

// 3. 批量处理文献笔记
api.transactional(() => {
  unprocessedNotes.forEach(note => {
    try {
      // 提取文献元数据
      const metadata = extractMetadata(note.getContent());
      
      // 添加标准化标签
      addStandardTags(note, metadata);
      
      // 更新状态标记
      note.removeLabel("status", UNPROCESSED_TAG.split(":")[1]);
      note.setLabel("status", PROCESSED_TAG.split(":")[1]);
      
      // 保存修改
      note.save();
      
      api.log(`已处理文献: ${note.title}`);
    } catch (error) {
      api.log(`处理文献失败 ${note.title}: ${error.message}`);
      // 事务会自动回滚失败的操作
    }
  });
});

// 辅助函数：提取文献元数据
function extractMetadata(content) {
  const metadata = {};
  
  // 提取作者（假设格式："作者: 张三, 李四"）
  const authorMatch = content.match(/作者:\s*(.+)/);
  if (authorMatch) metadata.authors = authorMatch[1].split(",").map(a => a.trim());
  
  // 提取发表年份（假设格式："年份: 2023"）
  const yearMatch = content.match(/年份:\s*(\d{4})/);
  if (yearMatch) metadata.year = yearMatch[1];
  
  // 提取研究领域（假设格式："领域: 人工智能"）
  const fieldMatch = content.match(/领域:\s*(.+)/);
  if (fieldMatch) metadata.field = fieldMatch[1];
  
  return metadata;
}

// 辅助函数：添加标准化标签
function addStandardTags(note, metadata) {
  // 添加作者标签
  if (metadata.authors) {
    metadata.authors.forEach(author => {
      note.setLabel("author", author);
    });
  }
  
  // 添加年份标签
  if (metadata.year) {
    note.setLabel("year", metadata.year);
  }
  
  // 添加领域标签
  if (metadata.field) {
    note.setLabel("field", metadata.field);
  }
}

关键解析

事务处理机制：使用api.transactional()确保所有文献处理要么全部成功，要么全部失败，避免部分处理导致的数据不一致。事务处理实现可参考[src/services/core/transaction.js]中的实现。
元数据提取策略：通过正则表达式从文献笔记中提取结构化信息，这是从非结构化文本中获取有用数据的基础技术。实际应用中可结合NLP技术提高提取准确率。
标签标准化：通过统一的标签体系（author:, year:, field:）使文献笔记具有一致的组织结构，为后续的搜索和关联奠定基础。

注意事项

适用场景：适用于有固定格式的文献笔记处理，如学术论文摘要、技术报告等。
局限性：依赖固定格式的元数据表示，对于格式不规范的笔记处理效果有限。
性能考量：单次处理笔记数量建议控制在50篇以内，大量笔记处理可分批次进行。

💡 技巧：可结合#trigger=daily属性实现每日自动处理，确保新添加的文献笔记及时得到整理。

案例一：研究文献自动处理系统（进阶版）

场景描述

在基础版基础上，增加PDF内容自动提取、引用网络构建和相关文献推荐功能，实现从文献导入到知识网络构建的全流程自动化。

核心代码实现

// == 高级文献处理系统 ==
const LITERATURE_FOLDER_ID = "literature-reviews";
const PROCESSED_TAG = "status:processed";
const UNPROCESSED_TAG = "status:unprocessed";
const PDF_ATTACHMENT_TYPE = "application/pdf";

// 主处理函数
async function processLiteratureNotes() {
  // 1. 搜索带PDF附件的未处理笔记
  const candidateNotes = api.searchForNotes(`#${UNPROCESSED_TAG}`);
  const unprocessedNotes = [];
  
  // 筛选包含PDF附件的笔记
  for (const note of candidateNotes) {
    const attachments = await api.getNoteAttachments(note.noteId);
    if (attachments.some(a => a.mimeType === PDF_ATTACHMENT_TYPE)) {
      unprocessedNotes.push(note);
    }
  }
  
  if (unprocessedNotes.length === 0) {
    api.showMessage("没有待处理的PDF文献笔记", "info");
    return;
  }
  
  // 2. 处理每篇文献
  for (const note of unprocessedNotes) {
    try {
      await processSingleNote(note);
      api.log(`成功处理文献: ${note.title}`);
    } catch (error) {
      api.log(`处理文献 ${note.title} 失败: ${error.message}`);
    }
  }
}

// 处理单篇文献
async function processSingleNote(note) {
  // 获取PDF附件
  const attachments = await api.getNoteAttachments(note.noteId);
  const pdfAttachment = attachments.find(a => a.mimeType === PDF_ATTACHMENT_TYPE);
  
  if (!pdfAttachment) {
    throw new Error("未找到PDF附件");
  }
  
  // 从PDF提取文本
  const pdfText = await api.extractTextFromPdf(pdfAttachment.attachmentId);
  
  // 解析文献元数据
  const metadata = parseLiteratureMetadata(pdfText);
  
  // 更新笔记内容和属性
  api.transactional(() => {
    // 更新笔记标题为文献标题
    if (metadata.title) {
      note.title = metadata.title;
    }
    
    // 添加结构化内容
    const structuredContent = generateStructuredContent(metadata, pdfText);
    note.setContent(structuredContent);
    
    // 添加元数据标签
    addMetadataTags(note, metadata);
    
    // 更新处理状态
    note.removeLabel("status", UNPROCESSED_TAG.split(":")[1]);
    note.setLabel("status", PROCESSED_TAG.split(":")[1]);
    
    note.save();
  });
  
  // 构建引用网络（在事务外执行，避免长时间锁定）
  await buildCitationNetwork(note, metadata.references);
  
  // 推荐相关文献
  await recommendRelatedLiterature(note, metadata.keywords);
}

// 解析文献元数据
function parseLiteratureMetadata(text) {
  // 实际应用中可使用更复杂的NLP算法
  const metadata = {
    title: extractTitle(text),
    authors: extractAuthors(text),
    year: extractYear(text),
    abstract: extractAbstract(text),
    keywords: extractKeywords(text),
    references: extractReferences(text)
  };
  
  return metadata;
}

// 生成结构化内容
function generateStructuredContent(metadata, fullText) {
  return `# ${metadata.title || "未识别标题"}\n\n` +
         `**作者**: ${metadata.authors ? metadata.authors.join(", ") : "未识别"}\n` +
         `**年份**: ${metadata.year || "未识别"}\n\n` +
         `## 摘要\n${metadata.abstract || "未提取到摘要"}\n\n` +
         `## 关键词\n${metadata.keywords ? metadata.keywords.join(", ") : "未提取到关键词"}\n\n` +
         `## 核心内容\n${extractCoreContent(fullText) || "内容提取失败"}\n\n` +
         `## 参考文献\n${metadata.references ? metadata.references.join("\n") : "未提取到参考文献"}`;
}

// 构建引用网络
async function buildCitationNetwork(currentNote, references) {
  if (!references || references.length === 0) return;
  
  for (const ref of references) {
    // 搜索已存在的引用文献
    const potentialNotes = api.searchForNotes(`title:"${ref.title}" AND #type:literature`);
    
    if (potentialNotes.length > 0) {
      // 创建双向引用
      api.createBranch(currentNote.noteId, potentialNotes[0].noteId, {
        type: "relation",
        name: "cites"
      });
      
      api.createBranch(potentialNotes[0].noteId, currentNote.noteId, {
        type: "relation",
        name: "cited-by"
      });
    }
  }
}

// 推荐相关文献
async function recommendRelatedLiterature(note, keywords) {
  if (!keywords || keywords.length === 0) return;
  
  // 基于关键词搜索相关文献
  const query = keywords.map(k => `text:${k}`).join(" OR ");
  const relatedNotes = api.searchForNotes(`${query} AND #type:literature -noteId:${note.noteId}`);
  
  if (relatedNotes.length > 0) {
    // 创建"相关文献"分支
    const relatedBranch = api.createNote(
      note.noteId, 
      "相关文献", 
      "", 
      {type: "text", isExpanded: false}
    );
    
    // 添加相关文献引用
    relatedNotes.slice(0, 5).forEach(relatedNote => {
      api.createBranch(relatedBranch.noteId, relatedNote.noteId, {
        type: "relation",
        name: "related-to"
      });
    });
  }
}

// 辅助函数：各种元数据提取函数
function extractTitle(text) { /* 实现细节 */ }
function extractAuthors(text) { /* 实现细节 */ }
function extractYear(text) { /* 实现细节 */ }
function extractAbstract(text) { /* 实现细节 */ }
function extractKeywords(text) { /* 实现细节 */ }
function extractReferences(text) { /* 实现细节 */ }
function extractCoreContent(text) { /* 实现细节 */ }

// 执行处理
processLiteratureNotes();

关键解析

PDF文本提取：通过api.extractTextFromPdf()接口从PDF附件中提取文本内容，为后续处理提供数据基础。PDF处理功能实现可参考[src/services/import/mime.js]。
元数据解析系统：通过一系列解析函数从文本中提取文献标题、作者、摘要等关键信息，为笔记结构化提供支持。
知识网络构建：通过识别参考文献自动创建笔记间的引用关系，实现知识网络的自动构建。分支管理实现可参考[src/services/branches.js]。
相关文献推荐：基于关键词的相似文献搜索，帮助用户发现相关研究，拓展知识视野。搜索功能实现可参考[src/services/search/]目录下的相关模块。

注意事项

适用场景：适用于学术研究、文献综述、技术调研等需要处理大量PDF文献的场景。
局限性：PDF文本提取准确率受PDF质量影响，复杂格式可能导致提取错误；元数据解析依赖文本模式匹配，对非标准格式文献效果有限。
性能考量：PDF处理和文本分析是计算密集型任务，建议在系统负载较低时运行，或限制单次处理文献数量。

💡 技巧：可结合OCR技术处理图片型PDF，进一步提高文本提取的覆盖率。相关功能可参考[src/services/image.js]中的图像识别接口。

案例二：跨场景知识整合助手

场景描述

现代知识工作者需要处理来自多种来源的信息，包括网页、邮件、电子书和会议记录等。这些信息分散在不同平台，难以形成统一的知识体系。本案例实现一个跨场景知识整合助手，自动从多种来源收集信息并整合到Trilium知识库中。

核心代码实现

// == 跨场景知识整合助手 ==
const INTEGRATION_FOLDER = "knowledge-integration";
const SOURCE_TAGS = {
  web: "source:web",
  email: "source:email",
  book: "source:book",
  meeting: "source:meeting"
};

// 主整合函数
async function integrateKnowledgeSources() {
  // 1. 配置各数据源
  const sources = [
    { type: "web", enabled: true, processor: processWebContent },
    { type: "email", enabled: true, processor: processEmailContent },
    { type: "book", enabled: true, processor: processBookExcerpts },
    { type: "meeting", enabled: true, processor: processMeetingNotes }
  ];
  
  // 2. 处理每个数据源
  for (const source of sources) {
    if (source.enabled) {
      try {
        await source.processor();
        api.log(`成功处理${source.type}来源的知识`);
      } catch (error) {
        api.log(`处理${source.type}来源失败: ${error.message}`);
      }
    }
  }
  
  // 3. 全局知识关联
  await buildGlobalKnowledgeRelations();
  
  api.showMessage("知识整合完成", "success");
}

// 网页内容处理
async function processWebContent() {
  // 获取待处理的网页内容（假设通过浏览器扩展收集到临时目录）
  const pendingWebContent = await api.getPendingContent("web-clips");
  
  for (const item of pendingWebContent) {
    // 创建网页笔记
    const { note } = api.createTextNote(
      INTEGRATION_FOLDER,
      item.title,
      generateWebContent(item)
    );
    
    // 添加标签
    note.setLabel("source", "web");
    note.setLabel("url", item.url);
    note.setLabel("domain", new URL(item.url).hostname);
    
    // 提取关键词并添加标签
    const keywords = extractKeywordsFromText(item.content);
    keywords.slice(0, 5).forEach(keyword => {
      note.setLabel("keyword", keyword);
    });
    
    note.save();
    
    // 标记为已处理
    await api.markAsProcessed("web-clips", item.id);
  }
}

// 邮件内容处理
async function processEmailContent() {
  // 从邮件服务器获取指定标签的邮件
  const emails = await api.fetchEmails({
    label: "to-process",
    maxCount: 20
  });
  
  for (const email of emails) {
    // 创建邮件笔记
    const { note } = api.createTextNote(
      INTEGRATION_FOLDER,
      `[邮件] ${email.subject}`,
      generateEmailContent(email)
    );
    
    // 添加标签
    note.setLabel("source", "email");
    note.setLabel("sender", email.from);
    note.setLabel("date", new Date(email.date).toISOString().split("T")[0]);
    
    // 检测邮件中的任务
    const tasks = extractTasksFromEmail(email.body);
    if (tasks.length > 0) {
      const taskNote = await createTaskNote(note.noteId, tasks);
      note.setRelation("contains-tasks", taskNote.noteId);
    }
    
    note.save();
    
    // 标记邮件为已处理
    await api.markEmailAsProcessed(email.id);
  }
}

// 书籍摘录处理
async function processBookExcerpts() {
  // 从阅读应用API获取新书摘
  const excerpts = await api.getNewBookExcerpts();
  
  for (const excerpt of excerpts) {
    // 检查是否已存在该书的笔记
    let bookNote = api.searchForNotes(`#book:${excerpt.bookId}`)[0];
    
    if (!bookNote) {
      // 创建新书笔记
      bookNote = api.createTextNote(
        INTEGRATION_FOLDER,
        excerpt.bookTitle,
        `# ${excerpt.bookTitle}\n\n**作者**: ${excerpt.author}\n**ISBN**: ${excerpt.isbn}\n\n## 内容摘要\n\n`
      ).note;
      
      bookNote.setLabel("source", "book");
      bookNote.setLabel("book", excerpt.bookId);
      bookNote.save();
    }
    
    // 添加书摘到书籍笔记
    const excerptText = `> ${excerpt.content}\n\n- 页码: ${excerpt.page}\n- 添加时间: ${new Date().toLocaleString()}\n`;
    bookNote.setContent(bookNote.getContent() + "\n## 摘录\n\n" + excerptText);
    bookNote.save();
    
    // 创建书摘独立笔记（用于交叉引用）
    const excerptNote = api.createTextNote(
      bookNote.noteId,
      `摘录: ${excerpt.content.substring(0, 50)}...`,
      excerptText
    ).note;
    
    // 提取关键词
    const keywords = extractKeywordsFromText(excerpt.content);
    keywords.slice(0, 3).forEach(keyword => {
      excerptNote.setLabel("keyword", keyword);
    });
    
    excerptNote.save();
  }
}

// 会议记录处理
async function processMeetingNotes() {
  // 获取今日会议记录
  const meetings = await api.getCalendarEvents({
    type: "meeting",
    date: new Date().toISOString().split("T")[0]
  });
  
  for (const meeting of meetings) {
    // 创建会议笔记
    const { note } = api.createTextNote(
      INTEGRATION_FOLDER,
      `[会议] ${meeting.title}`,
      generateMeetingContent(meeting)
    );
    
    // 添加标签
    note.setLabel("source", "meeting");
    note.setLabel("participants", meeting.attendees.join(","));
    note.setLabel("date", new Date(meeting.startTime).toISOString().split("T")[0]);
    
    // 提取行动项
    const actionItems = extractActionItems(meeting.transcript);
    if (actionItems.length > 0) {
      const taskNote = await createTaskNote(note.noteId, actionItems);
      note.setRelation("contains-tasks", taskNote.noteId);
    }
    
    note.save();
  }
}

// 构建全局知识关联
async function buildGlobalKnowledgeRelations() {
  // 获取所有整合的知识笔记
  const knowledgeNotes = api.searchForNotes(`#source:* AND parent:${INTEGRATION_FOLDER}`);
  
  // 为每篇笔记找到相似笔记
  for (const note of knowledgeNotes) {
    // 提取关键词
    const content = note.getContent();
    const keywords = extractKeywordsFromText(content).slice(0, 5);
    
    if (keywords.length === 0) continue;
    
    // 搜索相似笔记
    const query = keywords.map(k => `text:${k}`).join(" OR ");
    const similarNotes = api.searchForNotes(`${query} AND #source:* -noteId:${note.noteId}`);
    
    // 创建相似关系
    similarNotes.slice(0, 3).forEach(similarNote => {
      // 避免重复关系
      const existingRelations = api.getNoteRelations(note.noteId, "similar-to");
      if (!existingRelations.some(r => r.targetNoteId === similarNote.noteId)) {
        api.createRelation(note.noteId, similarNote.noteId, "similar-to");
      }
    });
  }
}

// 辅助函数
function generateWebContent(item) { /* 实现细节 */ }
function generateEmailContent(email) { /* 实现细节 */ }
function generateMeetingContent(meeting) { /* 实现细节 */ }
function extractKeywordsFromText(text) { /* 实现细节 */ }
function extractTasksFromEmail(body) { /* 实现细节 */ }
function extractActionItems(transcript) { /* 实现细节 */ }
async function createTaskNote(parentNoteId, tasks) { /* 实现细节 */ }

// 执行整合
integrateKnowledgeSources();

关键解析

多源数据整合架构：设计了统一的知识整合框架，通过插件式处理器支持不同来源的信息处理，体现了开闭原则（对扩展开放，对修改关闭）。
知识关联算法：基于关键词的相似性匹配，自动创建笔记间的"similar-to"关系，实现知识网络的自动构建。相似性计算实现可参考[src/becca/similarity.js]。
任务提取机制：从邮件和会议记录中自动识别任务项，并创建关联的任务笔记，实现从信息到行动的转化。
元数据标准化：为不同来源的信息添加标准化的元数据标签（source:, keyword:, date:等），确保知识的一致性和可检索性。

注意事项

适用场景：适用于需要处理多种信息来源的知识工作者，如研究人员、产品经理、内容创作者等。
局限性：依赖外部系统API（邮件、日历、阅读应用等），集成复杂度较高；跨语言内容处理能力有限。
安全考量：处理邮件等敏感信息时，需确保符合数据保护法规，相关安全措施可参考[src/services/encryption/]目录下的安全模块。

💡 技巧：可通过#trigger=weekly属性设置每周执行一次，或结合前端面板实现手动触发，平衡信息时效性和系统性能。

应用拓展：脚本开发进阶与最佳实践

模块化脚本设计

随着脚本功能的复杂化，采用模块化设计变得至关重要。模块化不仅提高代码复用率，还能提升可维护性和扩展性。

模块划分策略

知识处理系统
├── core/              # 核心模块
│   ├── metadata.js    # 元数据提取
│   ├── tagging.js     # 标签管理
│   └── relations.js   # 关系构建
├── sources/           # 数据源模块
│   ├── web.js         # 网页内容处理
│   ├── email.js       # 邮件处理
│   └── pdf.js         # PDF处理
└── utils/             # 工具函数
    ├── nlp.js         # 自然语言处理
    ├── format.js      # 格式转换
    └── storage.js     # 存储操作

模块实现示例

// 模块: utils/nlp.js
exports.extractKeywords = function(text, count = 5) {
  // 关键词提取实现
  // ...
  return keywords.slice(0, count);
};

exports.summarizeText = function(text, length = 150) {
  // 文本摘要实现
  // ...
  return summary;
};

// 主脚本中使用模块
const nlp = require("utils/nlp");
const keywords = nlp.extractKeywords(noteContent);
const summary = nlp.summarizeText(longContent);

模块系统的实现可参考[src/services/script_context.js]中的脚本加载机制。

性能优化策略

脚本性能直接影响用户体验，尤其是处理大量数据时。以下是几种关键优化策略：

批量操作优化

// 未优化：多次数据库操作
notes.forEach(note => {
  note.setLabel("processed", "true");
  note.save(); // 每次save()都会触发数据库操作
});

// 优化后：事务批量处理
api.transactional(() => {
  notes.forEach(note => {
    note.setLabel("processed", "true");
  });
  // 事务提交时一次性保存所有更改
});

事务处理机制通过减少数据库交互次数，显著提升批量操作性能。

结果缓存

// 缓存搜索结果
function getFrequentlyUsedNotes() {
  const cacheKey = "frequent-notes";
  
  // 检查缓存
  if (api.cache[cacheKey] && api.cache[cacheKey].timestamp > Date.now() - 3600000) {
    return api.cache[cacheKey].data;
  }
  
  // 缓存未命中，执行搜索
  const results = api.searchForNotes("#frequent:yes");
  
  // 更新缓存
  api.cache[cacheKey] = {
    data: results,
    timestamp: Date.now()
  };
  
  return results;
}

合理使用缓存可以避免重复计算和数据库查询，尤其适用于频繁访问但不常变化的数据。

异步处理

// 并行处理多个独立任务
async function processIndependentTasks(tasks) {
  // 使用Promise.all并行处理
  const results = await Promise.all(
    tasks.map(task => processSingleTask(task))
  );
  
  return results;
}

对于独立的处理任务，使用并行处理可以显著缩短总执行时间。

常见问题排查

在Trilium脚本开发过程中，可能会遇到各种问题。以下是几个常见问题及解决方案：

问题1：脚本执行超时

症状：复杂脚本在执行过程中突然停止，没有任何错误提示。

原因：Trilium对脚本执行时间有默认限制，防止长时间运行的脚本阻塞系统。

解决方案：

// 方案1：拆分长任务
async function processLargeDataset(items) {
  const batchSize = 50;
  
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    await processBatch(batch);
    
    // 给系统留出处理其他任务的时间
    await new Promise(resolve => setTimeout(resolve, 100));
  }
}

// 方案2：使用后台任务API（如果可用）
api.runInBackground(async () => {
  // 长时间运行的任务
});

任务调度实现可参考[src/services/scheduler.js]。

问题2：数据库操作冲突

症状：并发修改同一笔记时出现数据不一致或保存失败。

原因：多个脚本或用户操作同时修改同一笔记，导致数据库冲突。

解决方案：

// 使用乐观锁机制
async function safeUpdateNote(noteId, updateFn) {
  const maxRetries = 3;
  let retries = 0;
  
  while (retries < maxRetries) {
    try {
      // 获取最新版本
      const note = api.getNoteById(noteId);
      const originalVersion = note.version;
      
      // 应用更新
      updateFn(note);
      
      // 保存时检查版本
      note.save({ checkVersion: originalVersion });
      return true;
    } catch (error) {
      if (error.code === "VERSION_CONFLICT" && retries < maxRetries - 1) {
        retries++;
        await new Promise(resolve => setTimeout(resolve, 100 * (retries + 1)));
      } else {
        throw error;
      }
    }
  }
  
  throw new Error("达到最大重试次数");
}

// 使用示例
safeUpdateNote(noteId, note => {
  note.setLabel("category", "updated");
});

版本控制实现可参考[src/becca/entities/brevision.js]中的修订管理机制。

问题3：内存使用过高

症状：脚本执行过程中系统变慢或崩溃。

原因：处理大量数据时，将所有数据加载到内存导致内存溢出。

解决方案：

// 采用流式处理而非一次性加载
async function processLargeFile(filePath, processLine) {
  const stream = api.createReadStream(filePath);
  let buffer = "";
  
  for await (const chunk of stream) {
    buffer += chunk;
    const lines = buffer.split("\n");
    buffer = lines.pop() || "";
    
    for (const line of lines) {
      await processLine(line);
    }
  }
  
  if (buffer) {
    await processLine(buffer);
  }
}

流处理实现可参考[src/services/blob.js]中的文件处理机制。

问题4：API权限不足

症状：调用某些API时出现"权限不足"错误。

原因：后端脚本和前端脚本拥有不同的API访问权限，某些操作需要特定权限。

解决方案：

// 前端脚本需要后端操作时，使用消息传递
if (api.isFrontend) {
  // 前端：发送请求到后端
  const result = await api.sendMessageToBackend("processData", { param1: "value1" });
} else {
  // 后端：注册消息处理器
  api.registerBackendMessageHandler("processData", async (params) => {
    // 执行需要权限的操作
    return processData(params);
  });
}

前后端通信机制可参考[src/services/ws.js]中的WebSocket实现。

问题5：搜索性能低下

症状：复杂搜索查询执行缓慢。

原因：未优化的搜索查询或缺少适当的索引。

解决方案：

// 优化搜索查询
function optimizedSearch(query) {
  // 1. 使用标签过滤优先
  const tagFilter = query.tags.map(tag => `#${tag}`).join(" AND ");
  
  // 2. 限制文本搜索范围
  const textSearch = query.text ? `text:"${query.text}"` : "";
  
  // 3. 组合查询
  const fullQuery = [tagFilter, textSearch].filter(Boolean).join(" AND ");
  
  // 4. 使用分页减少结果集大小
  return api.searchForNotes(fullQuery, { limit: 50, offset: 0 });
}