QQ空间自动点赞评论脚本使用指南

作者：祝愿我上钱一班

版本：1.1

简介

这是一个专为QQ空间设计的自动化点赞和评论工具，可以帮助你自动浏览好友动态并进行互动。无需下载安装任何软件，只需要在浏览器中打开QQ空间并运行这段代码，就能实现自动化操作。对于想要提高QQ空间活跃度但又没有太多时间手动操作的用户来说，这是一个非常实用的小工具。

💡 零基础提示：这个工具实际上是一段JavaScript代码，它可以在浏览器中自动执行一些你平时需要手动完成的操作，比如点赞和评论。不需要担心代码看起来复杂，按照本指南操作即可轻松使用。

功能特点

• 智能判断：自动识别哪些动态已经点过赞或已经评论过，避免重复操作
• 灵活配置：支持仅点赞模式、点赞+评论模式，可根据需求灵活设置
• 随机评论：从评论库中随机选择评论内容，使互动看起来更自然
• 自动翻页：处理完当前页面的内容后，会自动滚动加载更多动态
• 操作可控：可以设置最大操作数量，随时可以停止运行
• 详细反馈：在浏览器控制台清晰显示每一步的操作结果

使用方法

基础使用步骤

1. 打开QQ空间：确保你已经登录QQ空间
2. 打开浏览器控制台：
   • 在Windows上按下键盘上的 F12 键
   • 或者右键点击页面空白处，选择"检查"或"审查元素"
3. 粘贴代码：将提供的脚本代码完整复制，粘贴到控制台中
4. 执行代码：按回车键执行
5. 启动功能：在控制台中输入启动命令（见下方常用启动模式）

💡 零基础提示：控制台是浏览器中的一个工具，允许开发者执行代码。不要担心它看起来很技术化，你只需要把它当作一个输入命令的地方即可。

常用启动模式

根据你的需求，可以选择不同的启动命令：

// 1. 标准模式：先点赞后评论
QzAllInOne.start()

// 2. 仅点赞模式：只点赞不评论
QzAllInOne.start({doComment: false})

// 3. 智能模式：跳过已点赞的内容，只处理新内容
QzAllInOne.start({skipLiked: true})

// 4. 超级节省模式：跳过已点赞内容且不评论
QzAllInOne.start({skipLiked: true, doComment: false})

💡 零基础提示：上面的命令中，花括号 {} 里面的内容是设置项，可以控制脚本的行为。例如 doComment: false 表示不进行评论，只点赞。

进阶设置选项

如果你想更精细地控制脚本的行为，可以使用以下高级设置：

QzAllInOne.start({
  // 最多处理多少条动态，设为0表示不限制
  maxActions: 20,
  
  // 处理每条动态的间隔时间(毫秒)，1000毫秒=1秒
  actionInterval: 8000,
  
  // 是否跳过已点赞的内容
  skipLiked: true,
  
  // 是否进行评论
  doComment: true,
  
  // 点赞失败时是否仍然评论
  commentWithoutLike: false,
  
  // 自定义评论内容
  commentTexts: [
    "不错的分享，点赞支持！",
    "每天打卡必赞~",
    "你的动态总是这么有趣！" 
  ]
})

其他实用命令：

// 停止运行
QzAllInOne.stop()

// 添加一条新评论到评论库
QzAllInOne.addComment("这条动态真棒！")

// 查看当前运行状态和统计信息
QzAllInOne.getStats()

// 设置为仅点赞模式
QzAllInOne.setOnlyLike(true)

// 设置跳过已点赞内容
QzAllInOne.setSkipLiked(true)

代码详解

核心概念解析

对于零基础的朋友，先了解几个基本概念：

1. 函数：就像是一个能完成特定任务的机器人。例如，start()函数的任务是启动整个脚本。

2. 参数：给函数的指令或材料。例如，当我们写QzAllInOne.start({doComment: false})时，{doComment: false}就是参数，告诉函数"不要评论"。

3. 变量：用来存储信息的容器。例如，config变量存储了所有配置信息。

4. 条件判断：让程序能够作出决策。例如，if(isAlreadyLiked)表示"如果已经点过赞了，那么…"

5. 对象：包含多个相关数据的集合。例如stats对象包含了点赞数、评论数等统计信息。

6. 数组：多个数据的有序集合。例如commentTexts数组包含了多条评论内容。

主要函数分析

脚本中的主要函数及其作用：

1. start() - 启动函数

这是脚本的入口，负责初始化和开始整个自动化过程。

function start(options = {}) {
  // 合并配置，检查环境，重置统计，启动处理流程
}

代码解释：

• options = {}表示如果不提供参数，就使用空对象作为默认值
• 函数内部会检查当前是否在QQ空间环境
• 初始化各种统计数据
• 设置必要的监听器
• 开始处理第一批动态

2. processPost() - 处理单条动态

负责处理单条动态的点赞和评论操作。

async function processPost(post, postId) {
  // 确保动态可见，执行点赞，如果点赞成功且需要评论则执行评论
}

代码解释：

• async表示这是一个异步函数，可以等待耗时操作完成
• post是动态的HTML元素，postId是动态的唯一标识
• 函数内部首先滚动到该动态位置
• 然后执行点赞操作
• 如果点赞成功且配置了需要评论，则执行评论操作

3. performLike() - 执行点赞操作

负责查找点赞按钮并执行点赞。

async function performLike(post, postId) {
  // 查找点赞按钮，检查是否已点赞，执行点赞并验证结果
}

代码解释：

• 首先检查是否已经点过赞
• 如果已点赞且设置了跳过已点赞内容，则直接返回成功
• 否则点击点赞按钮并等待一段时间
• 检查点赞是否成功，并返回结果

4. performComment() - 执行评论操作

负责添加随机评论。

async function performComment(post, postId) {
  // 检查是否已评论，打开评论框，填写内容，发送评论
}

代码解释：

• 首先检查是否已经评论过
• 如果已评论且设置了跳过已评论内容，则直接返回成功
• 否则点击评论按钮打开评论框
• 从评论库中随机选择一条评论填入
• 点击发送按钮或按回车键发送
• 验证评论是否成功发送

5. isAlreadyLiked() - 检查是否已点赞

function isAlreadyLiked(likeButton) {
  // 通过多种方法检查点赞按钮状态
}

代码解释：

• 检查按钮的CSS类是否包含表示已点赞的标记
• 检查按钮颜色是否变为点赞后的颜色
• 检查按钮文本是否包含"已赞"或"取消"
• 检查点赞计数是否包含"我"

6. hasAlreadyCommented() - 检查是否已评论

function hasAlreadyCommented(post) {
  // 检查评论列表中是否有当前用户的评论
}

代码解释：

• 查找评论列表中是否包含当前登录用户的昵称
• 检查评论按钮文本是否有特殊提示
• 检查是否有删除自己评论的选项

7. findProcessablePosts() - 查找可处理的动态

function findProcessablePosts() {
  // 使用各种选择器查找页面上的动态
}

代码解释：

• 使用多种CSS选择器查找匹配QQ空间动态的元素
• 过滤掉广告和特殊内容
• 确保每条动态都有点赞和评论按钮

工作流程详解

整个脚本的工作流程如下：

1. 初始化阶段：

   • 加载配置
   • 检查环境
   • 重置统计数据
   • 设置监听器

2. 查找动态阶段：

   • 使用多种选择器查找页面上的动态
   • 过滤掉广告或不支持互动的内容

3. 处理动态阶段：

   • 对每条动态，先判断是否已处理过
   • 执行点赞操作（先判断是否已点赞）
   • 如需评论，执行评论操作（先判断是否已评论）
   • 记录处理结果

4. 自动加载更多阶段：

   • 处理完当前页面后自动滚动
   • 等待新内容加载
   • 继续处理新动态

5. 完成或停止阶段：

   • 达到最大处理数量或滚动到底部时完成
   • 或用户手动停止时结束
   • 输出统计结果

具体实现详解

下面我们深入了解脚本的具体实现细节，看看它是如何一步步完成自动点赞和评论的。

1. 脚本结构

整个脚本采用了一种叫做"立即执行函数表达式"(IIFE)的结构，这样可以避免变量污染全局空间：

const QzAllInOne = (function() {
  // 这里是所有的代码
  // ...
  
  // 最后返回公开API
  return {
    start, stop, setCommentTexts, /* 其他公开方法 */
  };
})();

💡 零基础提示：这种结构就像创建了一个封闭的空间，脚本内部的变量不会影响到网页的其他部分，避免冲突。

2. 配置和状态管理

脚本使用两个主要对象来管理配置和状态：

// 默认配置
const defaultConfig = {
  maxActions: 20,         // 最大操作数量
  actionInterval: 8000,   // 操作间隔
  doComment: true,        // 是否评论
  // 其他配置...
};

// 运行时状态
let stats = {
  started: false,        // 是否已启动
  processed: 0,          // 已处理数量
  liked: 0,              // 已点赞数量
  commented: 0,          // 已评论数量
  // 其他状态...
};

启动脚本时，用户的配置会与默认配置合并：

config = {...defaultConfig, ...options};

💡 零基础提示：{...a, ...b}是一种合并两个对象的简洁写法，如果有相同的属性，后面对象(b)的值会覆盖前面对象(a)的值。

3. 动态查找实现

脚本如何找到页面上的动态？这是通过CSS选择器实现的：

function findProcessablePosts() {
  const selectors = [
    'li.f-single',        // 标准动态列表项
    'div.f-single',       // 替代形式
    'li[id^="fct_"]',     // 基于ID前缀
    // 其他选择器...
  ];
  
  // 使用这些选择器查找元素
  const posts = [];
  selectors.forEach(selector => {
    const found = document.querySelectorAll(selector);
    // 添加到结果数组...
  });
  
  // 过滤掉不可处理的内容
  return posts.filter(post => {
    // 过滤逻辑...
  });
}

💡 零基础提示：CSS选择器是一种用来查找网页元素的语法。比如li.f-single表示"查找所有类名为f-single的li元素"。

4. 点赞实现

点赞功能的核心是找到点赞按钮并模拟点击：

async function performLike(post, postId) {
  // 1. 查找点赞按钮
  const likeButton = findLikeButton(post);
  
  // 2. 检查是否已点赞
  if (isAlreadyLiked(likeButton)) {
    return true; // 已点赞，跳过
  }
  
  // 3. 执行点击
  clickElement(likeButton);
  
  // 4. 等待点赞反应
  await sleep(1000);
  
  // 5. 验证点赞是否成功
  return verifyLikeSuccess(post, likeButton);
}

查找点赞按钮的实现：

function findLikeButton(post) {
  // 1. 先查找特定图标
  const iconButton = post.querySelector('i.fui-icon.icon-op-praise');
  if (iconButton) {
    return iconButton.parentElement;
  }
  
  // 2. 尝试其他选择器
  const selectors = [
    'a[data-cmd="qz_like"]',
    '.qz_like_btn',
    // 其他可能的选择器...
  ];
  
  // 3. 尝试通过文本内容查找
  // ...
}

判断是否已点赞的实现：

function isAlreadyLiked(likeButton) {
  // 1. 通过类名判断
  if (likeButton.classList.contains('item-liked')) {
    return true;
  }
  
  // 2. 通过颜色判断
  const style = getComputedStyle(likeButton);
  if (style.color === 'rgb(251, 114, 153)') { // 粉红色通常表示已点赞
    return true;
  }
  
  // 3. 通过文本内容判断
  if (likeButton.textContent.includes('已赞')) {
    return true;
  }
  
  // 其他判断方法...
}

5. 评论实现

评论功能更复杂，包含多个步骤：

async function performComment(post, postId) {
  // 1. 检查是否已评论过
  if (hasAlreadyCommented(post)) {
    return true; // 已评论，跳过
  }
  
  // 2. 点击评论按钮打开评论框
  const commentButton = findCommentButton(post);
  clickElement(commentButton);
  await sleep(1500);
  
  // 3. 查找评论输入框
  const commentInput = findCommentInput(post);
  
  // 4. 生成随机评论内容
  const commentText = generateComment();
  
  // 5. 填写评论内容
  await fillCommentInput(commentInput, commentText);
  
  // 6. 发送评论
  const sendButton = findSendButton(post);
  if (sendButton) {
    clickElement(sendButton);
  } else {
    sendCommentByEnter(commentInput);
  }
  
  // 7. 验证评论是否成功
  await sleep(1500);
  return verifyCommentSuccess(post, commentText);
}

填写评论内容的实现：

async function fillCommentInput(input, text) {
  // 1. 判断输入框类型
  const isContentEditable = input.getAttribute('contenteditable') === 'true';
  
  if (isContentEditable) {
    // 2a. 处理可编辑div元素
    input.focus();
    input.innerHTML = '';
    document.execCommand('insertText', false, text);
  } else {
    // 2b. 处理textarea或input元素
    input.value = text;
    triggerEvent(input, 'input');
  }
}

6. 自动滚动加载更多

处理完当前页面的动态后，脚本会自动滚动加载更多内容：

async function scrollDown() {
  // 1. 记录当前页面高度
  const previousHeight = document.body.scrollHeight;
  
  // 2. 滚动页面
  window.scrollBy(0, config.scrollDistance);
  
  // 3. 等待新内容加载
  await sleep(config.scrollInterval);
  
  // 4. 检查页面高度是否变化
  const newHeight = document.body.scrollHeight;
  return newHeight > previousHeight; // 如果高度增加，说明加载了新内容
}

7. DOM操作工具函数

脚本包含多个用于DOM操作的工具函数：

// 模拟点击元素
function clickElement(element) {
  if (!element) return;
  
  try {
    // 尝试使用标准点击方法
    element.click();
  } catch (err) {
    // 降级：使用事件模拟点击
    const event = new MouseEvent('click', {
      bubbles: true,
      cancelable: true,
      view: window
    });
    element.dispatchEvent(event);
  }
}

// 检查元素是否可见
function isVisible(element) {
  if (!element) return false;
  
  const style = window.getComputedStyle(element);
  return style.display !== 'none' && 
         style.visibility !== 'hidden' && 
         element.offsetWidth > 0;
}

// 滚动到元素可见
function scrollToElement(element) {
  // 实现...
}

8. 评论内容生成

脚本从评论库中随机选择一条评论：

function generateComment() {
  const comments = config.commentTexts;
  if (comments.length === 0) {
    return "不错，支持一下！"; // 默认评论
  }
  
  const randomIndex = Math.floor(Math.random() * comments.length);
  return comments[randomIndex];
}

9. 错误处理

脚本包含错误处理逻辑，确保单个动态的错误不会影响整体运行：

try {
  // 尝试处理动态
  await processPost(post, postId);
} catch (err) {
  // 记录错误并继续处理下一条
  error(`处理帖子出错: ${err.message}`);
  stats.failed++;
}

常见问题解答

问：脚本运行时遇到了错误怎么办？

答：最常见的解决方法是刷新页面，重新执行脚本。如果持续出错，可能是QQ空间页面结构有变化，需要更新脚本。

问：为什么有些动态没有被点赞或评论？

答：可能的原因有：

• 该动态已经点赞/评论过（且设置了跳过已处理内容）
• 该动态是广告或特殊内容，不支持互动
• 点赞/评论操作失败（网络问题或页面交互问题）

问：如何停止脚本运行？

答：在控制台输入 QzAllInOne.stop() 即可停止。也可以刷新页面或关闭浏览器标签。

问：脚本会泄露我的QQ账号密码吗？

答：不会。脚本只在已登录的QQ空间页面上运行，不涉及账号密码处理，也不会向外部发送任何数据。

使用技巧

1. 自定义评论库：添加个性化的评论内容，使互动更加自然。

   QzAllInOne.setCommentTexts([
     "这个我喜欢👍",
     "不错的分享！",
     "最近怎么样？"
   ])
   

2. 控制处理速度：如果担心操作过于频繁，可以增加操作间隔时间。

   QzAllInOne.setInterval(10000)  // 设置为10秒间隔
   

3. 分批次处理：设置较小的最大操作数，完成后再启动下一批。

   QzAllInOne.start({maxActions: 10})  // 只处理10条
   

4. 先点赞后评论：如果想先对所有内容点赞，再进行评论，可以：

   // 第一步：只点赞
   QzAllInOne.start({doComment: false})
   // 待完成后
   // 第二步：只评论已点赞内容
   QzAllInOne.start({commentWithoutLike: true})
   

完整代码:

// ================ QQ空间自动点赞+评论联动脚本 ================
// 作者: 祝愿我上钱一班
// 版本: 1.0
// 功能说明: 在QQ空间自动给动态先点赞后评论，按顺序处理每条动态
// 使用方法: 在QQ空间页面打开控制台(F12)，粘贴此脚本，输入QzAllInOne.start()即可启动
// ==================================================

/**
 * QQ空间全能助手 - 集成点赞和评论功能
 */
const QzAllInOne = (function() {
  // =============== 配置区域 ===============
  const defaultConfig = {
    // 基本设置
    maxActions: 20,              // 最大操作次数(0表示不限制)
    actionInterval: 8000,        // 每个帖子的操作间隔(毫秒)
    autoScroll: true,            // 是否自动滚动加载更多内容
    scrollInterval: 2000,        // 滚动间隔(毫秒)
    scrollDistance: 800,         // 每次滚动距离(像素)
    
    // 点赞设置
    likeInterval: 1000,          // 点赞操作后等待时间(毫秒)
    skipLiked: true,             // 跳过已点赞的帖子
    
    // 评论设置
    doComment: true,             // 是否进行评论操作
    commentWithoutLike: false,   // 点赞失败时是否仍然评论
    commentDelay: 2000,          // 点赞后等待多久开始评论(毫秒)
    commentTexts: [
      "很棒的分享，谢谢！👍",
      "每天来看看，支持一下~",
      "最近怎么样？👋",
      "不错的内容，学习了",
      "路过支持一下~",
      "这个内容很有意思！",
      "感谢分享！",
      "很高兴看到你的更新😊",
      "继续加油哦！💪",
      "这个我很喜欢，已收藏"
    ],
    skipCommented: true,         // 跳过已评论过的帖子
    
    // 操作设置
    maxRetries: 3,               // 失败时最大重试次数
    retryDelay: 2000,            // 重试等待时间(毫秒)
    debugMode: true              // 调试模式(显示详细日志)
  };
  
  // 内部状态
  let config = {...defaultConfig};
  let stats = {
    started: false,
    processed: 0,
    skipped: 0,
    liked: 0,
    commented: 0,
    failed: 0,
    retries: 0
  };
  let processedPosts = new Set();  // 已处理帖子ID集合
  let observer = null;             // 动态监听器
  
  // =============== 核心函数 ===============
  
  /**
   * 启动自动点赞+评论
   * @param {Object} options - 可选配置参数
   */
  function start(options = {}) {
    if (stats.started) {
      log("脚本已在运行中，请勿重复启动");
      return;
    }
    
    // 合并配置
    config = {...defaultConfig, ...options};
    
    // 检查环境
    if (!isQzoneEnvironment()) {
      error("请在QQ空间页面运行此脚本!");
      return;
    }
    
    // 重置统计数据
    stats = {
      started: true,
      processed: 0,
      skipped: 0,
      liked: 0,
      commented: 0,
      failed: 0,
      retries: 0
    };
    processedPosts.clear();
    
    // 显示启动信息
    log("===== QQ空间自动点赞+评论助手启动 =====");
    log(`最大操作数: ${config.maxActions || "不限"}, 操作间隔: ${config.actionInterval}ms`);
    log(`已加载 ${config.commentTexts.length} 条评论模板`);
    
    if (config.doComment === false) {
      log("已设置仅执行点赞操作，不进行评论");
    } else {
      log(`先点赞${config.commentWithoutLike?'(可选)':'(必需)'}，${config.doComment !== false ? '后评论' : '不评论'}`);
    }
    
    // 添加必要的DOM扩展函数
    enhanceDom();
    
    // 设置动态监听(DOM变化时尝试处理)
    setupObserver();
    
    // 开始处理流程
    processNextBatch();
  }
  
  /**
   * 处理下一批帖子
   */
  async function processNextBatch() {
    if (!stats.started) return;
    
    // 检查是否达到最大操作数
    if (config.maxActions > 0 && stats.processed >= config.maxActions) {
      finish();
      return;
    }
    
    try {
      // 查找可处理的帖子
      const posts = findProcessablePosts();
      
      if (posts.length === 0) {
        if (config.autoScroll) {
          // 没有找到帖子时，滚动页面加载更多
          log("没有找到可处理的帖子，尝试滚动加载更多...");
          const hasMore = await scrollDown();
          
          if (hasMore) {
            // 等待新内容加载完成
            setTimeout(processNextBatch, config.scrollInterval);
          } else {
            log("已滚动到页面底部，没有更多内容了");
            finish();
          }
        } else {
          log("没有找到可处理的帖子");
          finish();
        }
        return;
      }
      
      // 处理找到的帖子
      log(`找到 ${posts.length} 个可处理的帖子`);
      
      // 对每个帖子进行处理
      for (const post of posts) {
        // 再次检查是否达到最大操作数或已停止
        if (!stats.started || (config.maxActions > 0 && stats.processed >= config.maxActions)) {
          finish();
          return;
        }
        
        // 获取帖子ID
        const postId = getPostId(post);
        
        // 检查是否已处理过
        if (processedPosts.has(postId)) {
          stats.skipped++;
          debug(`跳过已处理的帖子: ${postId}`);
          continue;
        }
        
        // 处理这条帖子(先点赞后评论)
        await processPost(post, postId);
        
        // 等待指定的间隔时间
        await sleep(config.actionInterval);
      }
      
      // 处理完当前批次后，继续查找下一批
      if (config.autoScroll) {
        await scrollDown();
      }
      
      // 安排下一批处理
      setTimeout(processNextBatch, config.scrollInterval);
      
    } catch (err) {
      error("处理帖子时出错:", err);
      // 错误后仍然继续尝试
      setTimeout(processNextBatch, config.retryDelay);
    }
  }
  
  /**
   * 处理单个帖子(先点赞后评论)
   * @param {Element} post - 帖子元素
   * @param {string} postId - 帖子ID
   */
  async function processPost(post, postId) {
    debug(`开始处理帖子: ${postId}`);
    log(`开始处理帖子 #${stats.processed + 1}: ${postId}`);
    
    try {
      // 确保帖子可见
      scrollToElement(post);
      await sleep(300);
      
      // 步骤1: 点赞
      const likeSuccess = await performLike(post, postId);
      
      // 等待点赞操作完成
      await sleep(config.likeInterval);
      
      // 步骤2: 评论(只有在设置了需要评论时进行)
      let commentSuccess = false;
      if (config.doComment !== false) {
        // 如果点赞成功或者设置了即使点赞失败也评论，则评论
        if (likeSuccess || config.commentWithoutLike) {
          await sleep(config.commentDelay);
          commentSuccess = await performComment(post, postId);
        } else {
          log(`跳过评论: 点赞未成功`);
        }
      } else {
        debug(`已设置不进行评论操作`);
      }
      
      // 记录处理成功
      processedPosts.add(postId);
      stats.processed++;
      
      // 返回详细的处理结果
      const result = {
        postId: postId,
        likeSuccess: likeSuccess,
        commentSuccess: commentSuccess
      };
      
      log(`✓ 处理完成 [${stats.processed}/${config.maxActions || "∞"}]: ${postId} 点赞:${likeSuccess?'成功':'失败'} 评论:${commentSuccess?'成功':config.doComment===false?'已禁用':'失败'}`);
      
      return result;
    } catch (err) {
      error(`处理帖子出错: ${err.message}`);
      stats.failed++;
      return {
        postId: postId,
        likeSuccess: false,
        commentSuccess: false,
        error: err.message
      };
    }
  }
  
  /**
   * 执行点赞操作
   * @param {Element} post - 帖子元素
   * @param {string} postId - 帖子ID
   */
  async function performLike(post, postId) {
    debug(`尝试点赞帖子: ${postId}`);
    
    try {
      // 查找点赞按钮
      const likeButton = findLikeButton(post);
      if (!likeButton) {
        debug("未找到点赞按钮");
        return false;
      }
      
      // 检查是否已点赞 - 更严格的判断
      if (isAlreadyLiked(likeButton)) {
        debug("该帖子已被点赞，跳过点赞操作");
        log(`✓ 帖子 ${postId} 已经点过赞了，无需重复点赞`);
        stats.skipped++;
        return true; // 已点赞也算成功
      }
      
      debug("找到点赞按钮，点击执行点赞");
      log(`正在点赞帖子: ${postId}`);
      clickElement(likeButton);
      
      // 等待点赞状态更新
      await sleep(1000);
      
      // 验证点赞是否成功 - 二次确认
      const isSuccess = verifyLikeSuccess(post, likeButton);
      
      if (isSuccess) {
        stats.liked++;
        debug(`点赞成功: ${postId}`);
        log(`✓ 点赞成功: ${postId}`);
        return true;
      } else {
        debug(`点赞可能失败: ${postId}，再次尝试验证`);
        
        // 额外等待一点时间再次验证
        await sleep(500);
        if (isAlreadyLiked(likeButton)) {
          stats.liked++;
          debug(`延迟验证点赞成功: ${postId}`);
          log(`✓ 点赞成功: ${postId}`);
          return true;
        }
        
        debug(`点赞失败: ${postId}`);
        log(`✗ 点赞失败: ${postId}`);
        return false;
      }
    } catch (err) {
      debug(`点赞操作出错: ${err.message}`);
      log(`✗ 点赞出错: ${postId}`);
      return false;
    }
  }
  
  /**
   * 执行评论操作
   * @param {Element} post - 帖子元素
   * @param {string} postId - 帖子ID
   */
  async function performComment(post, postId) {
    debug(`尝试评论帖子: ${postId}`);
    
    try {
      // 首先检查该帖子是否已评论过
      if (hasAlreadyCommented(post)) {
        debug("该帖子已评论过，跳过评论操作");
        log(`✓ 帖子 ${postId} 已经评论过了，无需重复评论`);
        stats.skipped++;
        return true; // 已评论也算成功
      }
      
      // 步骤1: 点击评论按钮打开评论框
      const commentButton = findCommentButton(post);
      if (!commentButton) {
        debug("未找到评论按钮");
        log(`✗ 评论失败: 未找到评论按钮`);
        return false;
      }
      
      debug("找到评论按钮，点击打开评论框");
      log(`正在准备评论帖子: ${postId}`);
      clickElement(commentButton);
      await sleep(1500); // 增加等待时间，确保评论框完全加载
      
      // 步骤2: 查找并填写评论框
      const commentInput = findCommentInput(post);
      if (!commentInput) {
        debug("未找到评论输入框");
        log(`✗ 评论失败: 未找到评论输入框`);
        return false;
      }
      
      // 生成随机评论内容
      const commentText = generateComment();
      debug(`找到评论框，填写内容: ${commentText}`);
      
      // 填写评论内容
      await fillCommentInput(commentInput, commentText);
      await sleep(500); // 短暂等待，确保内容填写完成
      
      // 步骤3: 查找并点击发送按钮
      const sendButton = findSendButton(post);
      if (!sendButton) {
        debug("未找到发送按钮");
        log(`✗ 评论失败: 未找到发送按钮`);
        // 尝试按回车键发送
        if (sendCommentByEnter(commentInput)) {
          debug("通过回车键发送评论");
          log(`尝试通过回车键发送评论`);
        } else {
          return false;
        }
      } else {
        debug("找到发送按钮，点击发送评论");
        log(`正在发送评论...`);
        clickElement(sendButton);
      }
      
      // 等待评论提交
      await sleep(1500);
      
      // 验证评论是否成功
      if (verifyCommentSuccess(post, commentText)) {
        stats.commented++;
        debug(`评论成功: ${postId}`);
        log(`✓ 评论成功: ${postId}`);
        return true;
      } else {
        debug(`评论可能失败，再次检查`);
        // 再次等待一段时间检查
        await sleep(1000);
        if (verifyCommentSuccess(post, commentText)) {
          stats.commented++;
          debug(`延迟验证评论成功: ${postId}`);
          log(`✓ 评论成功: ${postId}`);
          return true;
        }
        log(`✗ 评论可能失败: ${postId}`);
        return false;
      }
    } catch (err) {
      debug(`评论操作出错: ${err.message}`);
      log(`✗ 评论出错: ${postId}`);
      return false;
    }
  }
  
  /**
   * 检查帖子是否已被当前用户评论过
   * @param {Element} post - 帖子元素
   * @returns {boolean} 是否已评论
   */
  function hasAlreadyCommented(post) {
    try {
      // 1. 检查评论区是否有显示当前用户的头像或昵称
      const commentList = post.querySelector('.comments-list, .comment-list');
      if (commentList) {
        // 尝试找到评论列表中包含当前用户信息的评论
        const myComments = commentList.querySelectorAll('.comments-item, .comment-item');
        
        // 获取当前登录的QQ昵称元素
        const myNickElement = document.querySelector('.side_user a.nickname, .user-info .user-name');
        const myNick = myNickElement ? myNickElement.textContent.trim() : '';
        
        // 检查评论列表中是否有自己的评论
        for (const comment of myComments) {
          const commenterName = comment.querySelector('.nickname, .user-name');
          if (commenterName && commenterName.textContent.trim() === myNick) {
            return true;
          }
          
          // 检查评论者的QQ号或其他标识
          const commenterLink = comment.querySelector('a[href*="profile"]');
          if (commenterLink && commenterLink.href.includes('myself=true')) {
            return true;
          }
        }
      }
      
      // 2. 检查评论按钮文本是否有特殊提示(如"追评")
      const commentButton = findCommentButton(post);
      if (commentButton && commentButton.textContent.includes('追评')) {
        return true;
      }
      
      // 3. 检查是否有管理自己评论的选项
      const deleteCommentLinks = post.querySelectorAll('a[data-cmd="delComment"], .del-comment');
      if (deleteCommentLinks.length > 0) {
        return true;
      }
      
      return false;
    } catch (err) {
      debug(`检查评论状态出错: ${err.message}`);
      return false; // 出错时假设未评论过
    }
  }
  
  /**
   * 验证评论是否发送成功
   * @param {Element} post - 帖子元素
   * @param {string} commentText - 发送的评论内容
   * @returns {boolean} 评论是否成功发送
   */
  function verifyCommentSuccess(post, commentText) {
    try {
      // 1. 检查评论列表是否更新
      const commentList = post.querySelector('.comments-list, .comment-list');
      if (commentList) {
        const latestComment = commentList.querySelector('.comments-item:first-child, .comment-item:first-child');
        if (latestComment) {
          const commentContent = latestComment.querySelector('.comments-content, .comment-content');
          if (commentContent && commentContent.textContent.includes(commentText)) {
            return true;
          }
        }
      }
      
      // 2. 检查是否有评论成功的提示
      const successTip = document.querySelector('.qz-tip, .success-tip');
      if (successTip && isVisible(successTip)) {
        return true;
      }
      
      // 3. 检查评论框是否已清空或消失
      const commentInput = findCommentInput(post);
      if (commentInput) {
        // 如果输入框被清空，可能表示提交成功
        if (commentInput.textContent === '' || commentInput.value === '') {
          return true;
        }
      } else {
        // 如果输入框消失，也可能表示提交成功
        const commentArea = post.querySelector('.comment-box, .comments-box');
        if (commentArea && !commentArea.querySelector('textarea, [contenteditable="true"]')) {
          return true;
        }
      }
      
      // 4. 检查是否已经能找到刚才发送的评论
      return hasAlreadyCommented(post);
      
    } catch (err) {
      debug(`验证评论成功状态出错: ${err.message}`);
      return false;
    }
  }
  
  /**
   * 完成任务
   */
  function finish() {
    if (!stats.started) return;
    
    stats.started = false;
    
    if (observer) {
      observer.disconnect();
      observer = null;
    }
    
    log("===== 任务完成 =====");
    log(`处理帖子: ${stats.processed} 条`);
    log(`点赞成功: ${stats.liked} 条`);
    log(`评论成功: ${stats.commented} 条`);
    log(`跳过帖子: ${stats.skipped} 条`);
    log(`失败: ${stats.failed} 条`);
    
    // 返回统计结果
    return {
      processed: stats.processed,
      liked: stats.liked,
      commented: stats.commented,
      skipped: stats.skipped,
      failed: stats.failed
    };
  }
  
  /**
   * 停止任务
   */
  function stop() {
    if (!stats.started) {
      log("脚本尚未启动");
      return;
    }
    
    log("正在停止任务...");
    finish();
  }
  
  // =============== 辅助函数 ===============
  
  /**
   * 查找可处理的帖子
   * @returns {Array} 帖子元素数组
   */
  function findProcessablePosts() {
    // 基于QQ空间HTML结构，查找帖子容器
    const selectors = [
      'li.f-single',                   // 标准动态列表项
      'div.f-single',                  // 替代形式
      'li[id^="fct_"]',                // 基于ID前缀
      '.feed_list > li',               // 经典版动态列表
      '.feeds_item, .feeds-item',      // 其他可能形式
      '.feed-item'                     // 其他可能形式
    ];
    
    // 使用选择器查找元素
    const posts = [];
    selectors.forEach(selector => {
      const found = document.querySelectorAll(selector);
      debug(`使用选择器 "${selector}" 找到 ${found.length} 个元素`);
      
      for (const element of found) {
        if (!posts.includes(element)) {
          posts.push(element);
        }
      }
    });
    
    // 过滤掉没有点赞和评论功能的帖子
    return posts.filter(post => {
      // 广告和特殊内容通常没有互动功能
      if (post.classList.contains('f-single-biz') || 
          post.querySelector('.f-single-top .arrow-down.adFeedsItem')) {
        return false;
      }
      
      // 检查帖子是否有点赞和评论按钮
      const hasLikeBtn = !!findLikeButton(post);
      const hasCommentBtn = !!findCommentButton(post);
      
      return hasLikeBtn && hasCommentBtn;
    });
  }
  
  /**
   * 查找帖子中的点赞按钮
   * @param {Element} post - 帖子元素
   * @returns {Element|null} 点赞按钮元素
   */
  function findLikeButton(post) {
    // 优先查找带有特定图标类的元素
    const iconButton = post.querySelector('i.fui-icon.icon-op-praise');
    if (iconButton) {
      // 如果找到图标，获取其父元素（通常是a标签）
      return iconButton.parentElement;
    }
    
    // 如果无法通过图标找到，尝试其他选择器
    const selectors = [
      'a[data-cmd="qz_like"]',              // 标准点赞按钮
      '.qz_like_btn',                       // 常见类名
      'a[data-clicklog="like"]',            // 数据属性
      '.btn-praise',                        // 按钮类
      '.item-like-btn',                     // 点赞按钮类
      '.op-list a[data-link="0"]'           // 操作列表中的链接
    ];
    
    // 使用选择器查找
    for (const selector of selectors) {
      const button = post.querySelector(selector);
      if (button) return button;
    }
    
    // 根据文本内容查找可能的点赞按钮
    const allLinks = Array.from(post.querySelectorAll('a'));
    for (const link of allLinks) {
      if ((link.textContent.includes('赞') || 
           link.innerText.includes('👍')) && 
          !link.querySelector('*')) {
        return link;
      }
    }
    
    return null;
  }
  
  /**
   * 验证点赞是否成功
   * @param {Element} post - 帖子元素
   * @param {Element} likeButton - 点赞按钮元素
   * @returns {boolean} 点赞是否成功
   */
  function verifyLikeSuccess(post, likeButton) {
    // 首先检查按钮状态
    if (isAlreadyLiked(likeButton)) {
      return true;
    }
    
    // 检查帖子中的点赞数是否增加
    const likeCount = post.querySelector('.op-list .item:first-child .user-counts');
    if (likeCount && likeCount.innerText) {
      // 增加了点赞数，或者显示"我和xxx人点赞"
      if (likeCount.innerText.includes('我') || likeCount.innerText.includes('1')) {
        return true;
      }
    }
    
    // 检查点赞按钮颜色变化
    const style = getComputedStyle(likeButton);
    if (style.color === 'rgb(251, 114, 153)' || // 粉红色通常表示已点赞
        style.color === 'rgb(250, 60, 76)') {   // 红色也可能表示已点赞
      return true;
    }
    
    return false;
  }
  
  /**
   * 查找帖子中的评论按钮
   * @param {Element} post - 帖子元素
   * @returns {Element|null} 评论按钮元素
   */
  function findCommentButton(post) {
    // 基于用户提供的信息，优先查找带有特定图标类的元素
    const iconButton = post.querySelector('i.fui-icon.icon-op-comment');
    if (iconButton) {
      // 如果找到图标，获取其父元素（通常是a标签）
      return iconButton.parentElement;
    }
    
    // 如果无法通过图标找到，尝试其他选择器
    const selectors = [
      'a[data-cmd="qz_reply"]',              // 标准评论按钮
      '.qz_btn_reply',                       // 常见类名
      'a[data-clicklog="comment"]',          // 数据属性
      '.btn-comment',                        // 按钮类
      '.op-list a[data-link="1"]'            // 操作列表中的链接
    ];
    
    // 使用选择器查找
    for (const selector of selectors) {
      const button = post.querySelector(selector);
      if (button) return button;
    }
    
    // 根据文本内容查找可能的评论按钮
    const allLinks = Array.from(post.querySelectorAll('a'));
    for (const link of allLinks) {
      if (link.textContent.includes('评论') && !link.querySelector('*')) {
        return link;
      }
    }
    
    return null;
  }
  
  /**
   * 查找评论输入框
   * @param {Element} container - 容器元素，通常是帖子或评论区
   * @returns {Element|null} 评论输入框元素
   */
  function findCommentInput(container) {
    // 基于用户提供的信息，优先查找contenteditable的div
    const contentEditableInput = document.querySelector('div[contenteditable="true"].textinput.textarea.c_tx2');
    if (contentEditableInput && isVisible(contentEditableInput)) {
      return contentEditableInput;
    }
    
    // 扩大查找范围
    const extendedContainer = container.closest('.f-single') || document;
    
    // 查找评论输入框的各种可能选择器
    const selectors = [
      'div[contenteditable="true"].textinput',           // 常见选择器
      'div[contenteditable="true"].textarea.c_tx2',      // 另一种形式
      '.textinput[contenteditable="true"]',              // 可编辑div
      'div.textinput-default[contenteditable="true"]',   // 另一种形式
      '.comment-box textarea',                           // textarea形式
      '.comments-box .textinput',                        // 其他形式
      'textarea[placeholder*="评论"]',                   // 通过占位符查找
      '.qz-editor-editable'                              // 特殊编辑器
    ];
    
    // 使用选择器查找
    for (const selector of selectors) {
      const input = extendedContainer.querySelector(selector);
      if (input && isVisible(input)) return input;
    }
    
    // 如果在帖子中找不到，尝试在整个文档中查找最近出现的
    if (container !== document) {
      for (const selector of selectors) {
        const inputs = document.querySelectorAll(selector);
        for (const input of inputs) {
          if (isVisible(input)) return input;
        }
      }
    }
    
    return null;
  }
  
  /**
   * 查找发送按钮
   * @param {Element} container - 容器元素，通常是帖子或评论区
   * @returns {Element|null} 发送按钮元素
   */
  function findSendButton(container) {
    // 优先查找带有特定类的发表按钮
    const postButton = document.querySelector('a.btn-post.gb_bt');
    if (postButton && isVisible(postButton)) {
      return postButton;
    }
    
    // 扩大查找范围
    const extendedContainer = container.closest('.f-single') || document;
    
    // 查找发送按钮的各种可能选择器
    const selectors = [
      'a.btn-post.gb_bt',                // 常见选择器
      '.btn-post',                       // 按钮类
      '.submit-comment',                 // 常见类名
      '.comment-submit',                 // 另一种类名
      'a[data-cmd="postComment"]',       // 数据属性
      'button[type="submit"]',           // 提交按钮
      'input[type="submit"]'             // 提交输入
    ];
    
    // 使用选择器查找
    for (const selector of selectors) {
      const button = extendedContainer.querySelector(selector);
      if (button && isVisible(button)) return button;
    }
    
    // 如果在帖子中找不到，尝试在整个文档中查找
    if (container !== document) {
      for (const selector of selectors) {
        const buttons = document.querySelectorAll(selector);
        for (const button of buttons) {
          if (isVisible(button)) return button;
        }
      }
    }
    
    // 根据文本内容查找可能的发送按钮
    const allButtons = Array.from(document.querySelectorAll('a, button, input[type="button"]'));
    for (const button of allButtons) {
      if (button.textContent) {
        // 发送按钮通常包含以下文本
        if ((button.textContent.includes('发表') || 
            button.textContent.includes('发送') || 
            button.textContent.includes('确定')) && 
            isVisible(button)) {
          return button;
        }
      }
    }
    
    return null;
  }
  
  /**
   * 填写评论输入框
   * @param {Element} input - 输入框元素
   * @param {string} text - 评论文本
   */
  async function fillCommentInput(input, text) {
    try {
      // 确保元素可见
      scrollToElement(input);
      
      // 清除输入框中可能存在的占位文本
      const placeholder = input.querySelector('a.c_tx3[alt="replybtn"]');
      if (placeholder) {
        placeholder.remove();
      }
      
      // 判断输入框类型
      const isContentEditable = input.getAttribute('contenteditable') === 'true';
      
      if (isContentEditable) {
        // 可编辑div元素
        input.focus();
        
        // 清空内容
        input.innerHTML = '';
        
        try {
          // 使用execCommand插入文本
          document.execCommand('insertText', false, text);
        } catch (e) {
          // 如果execCommand失败，直接设置内容
          input.textContent = text;
        }
      } else {
        // textarea或input元素
        input.value = '';
        input.focus();
        
        // 设置值并触发事件
        input.value = text;
        triggerEvent(input, 'input');
        triggerEvent(input, 'change');
      }
    } catch (err) {
      debug(`填写评论输入框时出错: ${err.message}`);
      // 尝试最简单的方法
      if (input.value !== undefined) {
        input.value = text;
      } else {
        input.textContent = text;
      }
    }
  }
  
  /**
   * 尝试通过回车键发送评论
   * @param {Element} input - 输入框元素
   * @returns {boolean} 是否成功发送
   */
  function sendCommentByEnter(input) {
    try {
      // 创建回车事件
      const enterEvent = new KeyboardEvent('keydown', {
        bubbles: true,
        cancelable: true,
        keyCode: 13,
        which: 13,
        key: 'Enter'
      });
      
      // 触发回车事件
      input.dispatchEvent(enterEvent);
      return true;
    } catch (err) {
      debug(`通过回车键发送评论失败: ${err.message}`);
      return false;
    }
  }
  
  /**
   * 生成评论内容
   * @returns {string} 生成的评论文本
   */
  function generateComment() {
    // 从评论库中随机选择一条
    if (config.commentTexts.length === 0) {
      return "不错，支持一下！"; // 默认评论
    }
    
    const randomIndex = Math.floor(Math.random() * config.commentTexts.length);
    return config.commentTexts[randomIndex];
  }
  
  /**
   * 获取帖子的唯一ID
   * @param {Element} post - 帖子元素
   * @returns {string} 帖子ID
   */
  function getPostId(post) {
    // 尝试从ID属性获取
    if (post.id && post.id.startsWith('fct_')) {
      return post.id;
    }
    
    // 尝试从data-feedid属性获取
    const feedId = post.getAttribute('data-feedid') || 
                   post.getAttribute('data-id');
    if (feedId) {
      return feedId;
    }
    
    // 查找可能包含feed ID的元素
    const feedData = post.querySelector('[name="feed_data"]');
    if (feedData) {
      const fkey = feedData.getAttribute('data-fkey');
      if (fkey) {
        return fkey;
      }
    }
    
    // 使用内容哈希作为后备
    const content = post.innerText.slice(0, 100);
    return hashString(content);
  }
  
  /**
   * 生成哈希字符串
   * @param {string} str - 输入字符串
   * @returns {string} 哈希结果
   */
  function hashString(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // 转换为32位整数
    }
    return 'hash_' + Math.abs(hash).toString(16);
  }
  
  /**
   * 设置动态监听
   * 监听DOM变化，以便在加载新内容时触发处理
   */
  function setupObserver() {
    if (!window.MutationObserver) return;
    
    // 创建观察器实例
    observer = new MutationObserver((mutations) => {
      for (const mutation of mutations) {
        if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
          // 检查是否添加了新的帖子
          const hasFeedItems = Array.from(mutation.addedNodes).some(node => {
            if (node.nodeType !== Node.ELEMENT_NODE) return false;
            
            return node.classList && 
                  (node.classList.contains('f-single') || 
                   node.classList.contains('feed-item') ||
                   node.id && node.id.startsWith('fct_'));
          });
          
          // 如果添加了新帖子，可能需要处理
          if (hasFeedItems && stats.started) {
            debug("检测到新的帖子被添加到页面");
            // 不立即处理，等待变化完成
            clearTimeout(observer.timeout);
            observer.timeout = setTimeout(() => {
              processNextBatch();
            }, 1000);
          }
        }
      }
    });
    
    // 配置观察选项
    const config = { childList: true, subtree: true };
    
    // 开始观察
    observer.observe(document.body, config);
  }
  
  /**
   * 滚动页面加载更多内容
   * @returns {Promise<boolean>} 是否成功加载更多内容
   */
  async function scrollDown() {
    const previousHeight = document.body.scrollHeight;
    
    debug(`滚动页面加载更多内容(当前高度: ${previousHeight}px)`);
    
    // 滚动页面
    window.scrollBy(0, config.scrollDistance);
    
    // 等待内容加载
    await sleep(config.scrollInterval);
    
    // 检查是否有新内容加载
    const newHeight = document.body.scrollHeight;
    const hasMore = newHeight > previousHeight;
    
    debug(`滚动后页面高度: ${newHeight}px, ${hasMore ? '加载了新内容' : '没有加载新内容'}`);
    
    return hasMore;
  }
  
  /**
   * 检查元素是否可见
   * @param {Element} element - 要检查的元素
   * @returns {boolean} 元素是否可见
   */
  function isVisible(element) {
    if (!element) return false;
    
    // 获取计算样式
    const style = window.getComputedStyle(element);
    
    // 检查元素是否不可见
    return style.display !== 'none' && 
           style.visibility !== 'hidden' && 
           style.opacity !== '0' &&
           element.offsetWidth > 0 &&
           element.offsetHeight > 0;
  }
  
  /**
   * 滚动到元素可见
   * @param {Element} element - 要滚动到的元素
   */
  function scrollToElement(element) {
    if (!element) return;
    
    try {
      // 平滑滚动到元素
      element.scrollIntoView({ 
        behavior: 'smooth', 
        block: 'center',
        inline: 'nearest'
      });
    } catch (err) {
      // 兼容性处理
      const rect = element.getBoundingClientRect();
      const windowHeight = window.innerHeight || document.documentElement.clientHeight;
      const isInViewport = rect.top >= 0 && rect.bottom <= windowHeight;
      
      if (!isInViewport) {
        window.scrollTo(0, rect.top + window.pageYOffset - windowHeight / 2);
      }
    }
  }
  
  /**
   * 模拟点击元素
   * @param {Element} element - 要点击的元素
   */
  function clickElement(element) {
    if (!element) return;
    
    try {
      // 尝试使用内置click方法
      element.click();
    } catch (err) {
      // 兼容性处理：创建并分发点击事件
      try {
        const event = new MouseEvent('click', {
          bubbles: true,
          cancelable: true,
          view: window
        });
        element.dispatchEvent(event);
      } catch (e) {
        // 降级：使用旧版事件API
        const event = document.createEvent('MouseEvents');
        event.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
        element.dispatchEvent(event);
      }
    }
  }
  
  /**
   * 触发DOM事件
   * @param {Element} element - 目标元素
   * @param {string} eventType - 事件类型
   */
  function triggerEvent(element, eventType) {
    if (!element) return;
    
    try {
      // 创建事件
      const event = new Event(eventType, { bubbles: true });
      // 触发事件
      element.dispatchEvent(event);
    } catch (err) {
      // 降级处理
      try {
        const event = document.createEvent('HTMLEvents');
        event.initEvent(eventType, true, true);
        element.dispatchEvent(event);
      } catch (e) {
        debug(`触发事件失败: ${e.message}`);
      }
    }
  }
  
  /**
   * 检查当前是否在QQ空间环境
   * @returns {boolean} 是否在QQ空间
   */
  function isQzoneEnvironment() {
    return location.href.includes('qzone.qq.com');
  }
  
  /**
   * 添加DOM扩展函数
   * 为确保在不同浏览器环境下的兼容性
   */
  function enhanceDom() {
    // 如果Element原型没有remove方法，添加一个
    if (!Element.prototype.remove) {
      Element.prototype.remove = function() {
        if (this.parentNode) {
          this.parentNode.removeChild(this);
        }
      };
    }
  }
  
  /**
   * 等待指定时间
   * @param {number} ms - 等待毫秒数
   * @returns {Promise} Promise对象
   */
  function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  /**
   * 记录信息
   * @param {...any} args - 要记录的参数
   */
  function log(...args) {
    console.log('【QQ空间助手】', ...args);
  }
  
  /**
   * 记录调试信息
   * @param {...any} args - 要记录的参数
   */
  function debug(...args) {
    if (config.debugMode) {
      console.log('【调试】', ...args);
    }
  }
  
  /**
   * 记录错误信息
   * @param {...any} args - 要记录的参数
   */
  function error(...args) {
    console.error('【错误】', ...args);
  }
  
  // =============== 公开API ===============
  
  return {
    // 核心功能
    start,
    stop,
    
    // 配置修改
    setCommentTexts: function(texts) {
      if (Array.isArray(texts) && texts.length > 0) {
        config.commentTexts = texts;
        log(`已更新评论内容库，共${texts.length}条评论`);
        return true;
      }
      return false;
    },
    
    addComment: function(text) {
      if (typeof text === 'string' && text.trim()) {
        config.commentTexts.push(text.trim());
        log(`已添加新评论: "${text.trim()}"`);
        return true;
      }
      return false;
    },
    
    setInterval: function(ms) {
      if (ms > 0) {
        config.actionInterval = ms;
        log(`已设置操作间隔为 ${ms}ms`);
        return true;
      }
      return false;
    },
    
    setMaxActions: function(num) {
      config.maxActions = num;
      log(`已设置最大操作数为 ${num || '不限'}`);
      return true;
    },
    
    setLikeInterval: function(ms) {
      if (ms >= 0) {
        config.likeInterval = ms;
        log(`已设置点赞操作等待时间为 ${ms}ms`);
        return true;
      }
      return false;
    },
    
    setCommentDelay: function(ms) {
      if (ms >= 0) {
        config.commentDelay = ms;
        log(`已设置点赞后评论延迟为 ${ms}ms`);
        return true;
      }
      return false;
    },
    
    setDebugMode: function(enabled) {
      config.debugMode = !!enabled;
      log(`调试模式已${enabled ? '启用' : '禁用'}`);
      return true;
    },
    
    // 状态查询
    getStats: function() {
      return {...stats};
    },
    
    getConfig: function() {
      return {...config};
    },
    
    isRunning: function() {
      return stats.started;
    }
  };
})();

// 控制台帮助信息
console.log(`
=================================================
🤖 QQ空间自动点赞+评论助手 已加载
=================================================
使用方法:
1. QzAllInOne.start() - 开始自动点赞+评论
2. QzAllInOne.stop() - 停止自动操作

自定义设置:
- QzAllInOne.setCommentTexts(['评论1', '评论2']) - 更新评论库
- QzAllInOne.addComment('新评论') - 添加单条评论
- QzAllInOne.setInterval(8000) - 设置每个帖子的操作间隔(毫秒)
- QzAllInOne.setMaxActions(10) - 设置最大操作数量
- QzAllInOne.setLikeInterval(1000) - 设置点赞后等待时间(毫秒)
- QzAllInOne.setCommentDelay(2000) - 设置点赞后评论延迟(毫秒)
- QzAllInOne.setDebugMode(true) - 开启调试模式

查询状态:
- QzAllInOne.getStats() - 获取当前统计信息
- QzAllInOne.isRunning() - 检查是否正在运行
=================================================
`);

安全提示

1. 适度使用：请勿短时间内处理过多动态，以免被系统判定为异常行为。

2. 内容多样化：尽量使用多样化的评论内容，避免重复相同内容。

3. 注意隐私：在公共场所或共享电脑上使用时，注意个人隐私安全。

4. 遵守规则：遵守QQ空间的使用规则，不要进行违规操作。

5. 代码安全：只使用来自可信来源的脚本，避免运行未知来源的代码。

---

祝你使用愉快！如有问题，欢迎交流讨论。

文档最后更新：2025.5.17