一键教师好评脚本及在线网站

博主： lminyo
发布时间：2026 年 07 月 02 日
7 次浏览
暂无评论
45575字数
分类：默认分类

# 前言

最近又到了一学期就有一次的教师评价活动，每次点好几个老师真的是烦死了，于是我就搓了个脚本以及网站来实现懒人评价，你可以自定义自己的评价，或者你是同样的正方教务系统也可以使用，通过右上角设置按钮更改你的学校教务系统地址，如果你不放心自己的数据，可以使用我的油猴脚本

# 教程

没有教程，你可以前往以往文章查看油猴脚本部署教程，以往教程里面也带有油猴浏览器插件的下载地址，相关文章都有提供，或者互联网查询，或者使用AI工具如豆包、Deepseek查询如何部署自定义脚本到油猴脚本

# 在线使用

你可以直接使用内嵌模块进行一键提交

# 油猴脚本（复制粘贴应用到网站中）

```javascript
// ==UserScript==
// @name         正方一键评价
// @namespace    https://trae.local/zfsoft/xspj
// @version      1.0.0
// @description  正方教务学生评价一键填写、批量保存、批量提交，支持自定义评分和评语
// @author       Trae
// @match        *://*/xspjgl/xspj_cxXspjIndex.html*
// @run-at       document-idle
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @grant        unsafeWindow
// ==/UserScript==

(function () {
  'use strict';

const STORAGE_KEY = 'zfsoft-xspj-config';
  const PANEL_ID = 'zf-xspj-helper-panel';
  const BLOG_URL = 'https://lminyo.com/';
  const DEFAULT_CONFIG = {
    scoreMode: 'fixed',
    fixedScore: '100',
    scoreList: '100,95,90,85',
    commentMode: 'random',
    teacherComments: [
      '老师讲解清晰，教学认真负责，课堂节奏合理，整体收获很大。',
      '教师准备充分，授课条理清楚，课堂互动自然，学习体验很好。'
    ].join('\n'),
    courseComments: [
      '课程内容充实，知识脉络清晰，建议继续保持并适当增加案例讲解。',
      '整体教学效果很好，希望后续能增加更多实践或应用场景示例。'
    ].join('\n'),
    switchDelayMs: 1200,
    dialogDelayMs: 450,
    submitCooldownMs: 1400,
    autoConfirmDialog: true,
    actionMode: 'submit'
  };

const state = {
    running: false,
    stopRequested: false,
    lastBatchRowKey: '',
    sameRowRetry: 0,
    processedSaveRowKeys: new Set(),
    lastCommentPickMap: new Map(),
    blogVisitedForThisRun: false,
    taskItems: []
  };

// #region debug-point A:init
  const __debugSessionId = 'auto-eval-bug';
  const __debugServerUrl = 'http://127.0.0.1:7777/event';
  const __debugEnabled = false;
  function debugReport(hypothesisId, location, msg, data) {
    if (!__debugEnabled) {
      return;
    }
    fetch(__debugServerUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        sessionId: __debugSessionId,
        runId: 'post-fix-v1',
        hypothesisId,
        location,
        msg: `[DEBUG] ${msg}`,
        data: data || {},
        ts: Date.now()
      })
    }).catch(() => {});
  }
  // #endregion

function getPageWindow() {
    return typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
  }

function getPageJQuery() {
    return getPageWindow().jQuery || window.jQuery;
  }

function isReady() {
    return !!getPageJQuery() && !!document.querySelector('#tempGrid');
  }

function sleep(ms) {
    return new Promise((resolve) => window.setTimeout(resolve, ms));
  }

async function waitFor(checker, timeoutMs = 10000, intervalMs = 200) {
    const start = Date.now();
    while (Date.now() - start < timeoutMs) {
      const result = checker();
      if (result) {
        return result;
      }
      await sleep(intervalMs);
    }
    throw new Error('等待页面状态超时');
  }

function parsePositiveInt(value, fallback) {
    const num = Number(String(value).trim());
    return Number.isFinite(num) && num > 0 ? Math.floor(num) : fallback;
  }

function loadConfig() {
    return normalizeConfig(GM_getValue(STORAGE_KEY, DEFAULT_CONFIG));
  }

function saveConfig(config) {
    const normalized = normalizeConfig(config);
    GM_setValue(STORAGE_KEY, normalized);
    return normalized;
  }

function splitLines(text) {
    const raw = String(text || '');
    let lines = raw
      .split(/\r?\n/)
      .map((item) => item.trim())
      .filter(Boolean);

if (lines.length <= 1) {
      lines = raw
        .split(/\s*(?:\|\|\||\||；|;)\s*/)
        .map((item) => item.trim())
        .filter(Boolean);
    }

// 用户经常把多条评语直接连着粘成一段，这里按中文句号等终止符再拆一次。
    if (lines.length <= 1) {
      const sentenceParts = raw
        .split(/(?<=[。！？!?])/)
        .map((item) => item.trim())
        .filter(Boolean);
      if (sentenceParts.length > 1) {
        lines = sentenceParts;
      }
    }

// #region debug-point B:splitLines
    debugReport('B', '正方一键评价.user.js:splitLines', 'split lines result', {
      rawLength: raw.length,
      rawSample: raw.slice(0, 100),
      linesCount: lines.length,
      linesSample: lines.slice(0, 3)
    });
    // #endregion

if (!lines.length) {
      return ['整体评价良好'];
    }

return lines;
  }

function getScoreCandidates(config) {
    const list = splitLines(String(config.scoreList || '').replace(/,/g, '\n'))
      .map((item) => Number(item))
      .filter((item) => Number.isFinite(item));
    if (config.scoreMode === 'fixed') {
      const fixed = Number(config.fixedScore);
      return Number.isFinite(fixed) ? [fixed] : [100];
    }
    return list.length ? list : [100, 95, 90, 85];
  }

function escapeHtml(text) {
    return String(text || '')
      .replace(/&/g, '&')
      .replace(/</g, '<')
      .replace(/>/g, '>')
      .replace(/"/g, '"')
      .replace(/'/g, ''');
  }

function getRowTaskKey(row) {
    return `${row.__rowId || ''}__${row.jxb_id || ''}__${row.jgh_id || ''}`;
  }

function getRowDisplayName(row) {
    const course = row.kcmc || row.jxbmc || '未命名课程';
    const teacher = row.jzgmc || '未知教师';
    return `${course} / ${teacher}`;
  }

function resetTaskBoard() {
    state.taskItems = [];
    renderTaskBoard();
  }

function updatePanelForm(config) {
    const panel = document.getElementById(PANEL_ID);
    if (!panel) {
      return;
    }
    panel.querySelector('[name="scoreMode"]').value = config.scoreMode;
    panel.querySelector('[name="fixedScore"]').value = config.fixedScore;
    panel.querySelector('[name="scoreList"]').value = config.scoreList;
    panel.querySelector('[name="commentMode"]').value = config.commentMode;
    panel.querySelector('[name="teacherComments"]').value = config.teacherComments;
    panel.querySelector('[name="courseComments"]').value = config.courseComments;
    panel.querySelector('[name="switchDelayMs"]').value = String(config.switchDelayMs);
    panel.querySelector('[name="dialogDelayMs"]').value = String(config.dialogDelayMs);
    panel.querySelector('[name="submitCooldownMs"]').value = String(config.submitCooldownMs);
    panel.querySelector('[name="autoConfirmDialog"]').checked = config.autoConfirmDialog;
    panel.querySelector('[name="actionMode"]').value = config.actionMode;
  }

function buildPanelHtml() {
    return `
      <div class="zf-head">
        <span>正方一键评价</span>
        <button type="button" class="zf-collapse">收起</button>
      </div>
      <div class="zf-body">
        <label>评分模式
          <select name="scoreMode">
            <option value="fixed">固定分</option>
            <option value="random">随机分</option>
            <option value="rotate">轮换分</option>
          </select>
        </label>
        <label>固定分
          <input name="fixedScore" type="text" placeholder="100">
        </label>
        <label>分值列表
          <input name="scoreList" type="text" placeholder="100,95,90,85">
        </label>
        <label>评语模式
          <select name="commentMode">
            <option value="random">随机抽取</option>
            <option value="rotate">顺序轮换</option>
          </select>
        </label>
        <label>教师评语
          <textarea name="teacherComments" rows="3" placeholder="一行一条"></textarea>
        </label>
        <label>课程评语
          <textarea name="courseComments" rows="3" placeholder="一行一条"></textarea>
        </label>
        <label>切课等待(ms)
          <input name="switchDelayMs" type="number" min="200" step="100">
        </label>
        <label>弹窗等待(ms)
          <input name="dialogDelayMs" type="number" min="100" step="50">
        </label>
        <label>提交冷却(ms)
          <input name="submitCooldownMs" type="number" min="300" step="100">
        </label>
        <label class="zf-checkbox">
          <input name="autoConfirmDialog" type="checkbox">
          自动确认弹窗
        </label>
        <label>处理后动作
          <select name="actionMode">
            <option value="save">保存</option>
            <option value="submit">提交</option>
          </select>
        </label>
        <div class="zf-actions">
          <button type="button" data-action="save-config">保存配置</button>
          <button type="button" data-action="start-auto" style="grid-column: 1 / -1; background: #2ea44f;">一键全自动</button>
          <button type="button" data-action="stop" class="zf-danger" style="grid-column: 1 / -1;">停止</button>
        </div>
        <div class="zf-progress">
          <div class="zf-progress-text">任务进度 0/0</div>
          <div class="zf-progress-bar"><div class="zf-progress-fill"></div></div>
        </div>
        <div class="zf-task-list"></div>
        <div class="zf-license">
          版权说明：使用前需先访问一次 <a href="${BLOG_URL}" target="_blank" rel="noopener noreferrer">LMINYO 博客</a>。每次手动开始使用时触发一次，不会在批量切换课程时重复触发。
        </div>
        <div class="zf-status">就绪</div>
      </div>
    `;
  }

function createPanel() {
    if (document.getElementById(PANEL_ID)) {
      return;
    }
    injectStyles();
    const panel = document.createElement('div');
    panel.id = PANEL_ID;
    panel.innerHTML = buildPanelHtml();
    document.body.appendChild(panel);

const collapseBtn = panel.querySelector('.zf-collapse');
    collapseBtn.addEventListener('click', () => {
      panel.classList.toggle('zf-collapsed');
      collapseBtn.textContent = panel.classList.contains('zf-collapsed') ? '展开' : '收起';
    });

panel.querySelector('[data-action="save-config"]').addEventListener('click', () => {
      const config = saveConfig(getCurrentConfigFromPanel());
      updatePanelForm(config);
      setStatus('配置已保存');
    });

panel.querySelector('[data-action="start-auto"]').addEventListener('click', async () => {
      await safeRun(async () => {
        await ensureBlogVisited();
        const config = saveConfig(getCurrentConfigFromPanel());
        await processBatch(config.actionMode);
      });
    });

panel.querySelector('[data-action="stop"]').addEventListener('click', () => {
      state.stopRequested = true;
      state.running = false;
      setStatus('已请求停止');
    });

updatePanelForm(loadConfig());
    renderTaskBoard();
  }

async function safeRun(task) {
    try {
      await task();
    } catch (error) {
      console.error('[正方一键评价] ', error);
      setStatus(error.message || '执行失败', true);
    }
  }

async function ensureBlogVisited() {
    if (state.blogVisitedForThisRun) {
      return;
    }
    window.open(BLOG_URL, '_blank', 'noopener,noreferrer');
    state.blogVisitedForThisRun = true;
    setStatus('已打开 LMINYO 博客，本次使用已授权');
    await sleep(300);
  }

function isElementVisible(node) {
    if (!node || typeof node !== 'object' || node.nodeType !== 1) {
      return false;
    }
    const style = window.getComputedStyle(node);
    return style.display !== 'none' && style.visibility !== 'hidden';
  }

function getCurrentGridPage() {
    const { grid } = getGridApi();
    const value = typeof grid.jqGrid === 'function' ? grid.jqGrid('getGridParam', 'page') : 1;
    return Math.max(1, Number(value) || 1);
  }

function getLastGridPage() {
    const { grid } = getGridApi();
    const value = typeof grid.jqGrid === 'function' ? grid.jqGrid('getGridParam', 'lastpage') : 1;
    return Math.max(1, Number(value) || 1);
  }

async function goToGridPage(targetPage) {
    const { grid } = getGridApi();
    const expectedPage = Math.max(1, Number(targetPage) || 1);
    if (getCurrentGridPage() === expectedPage) {
      return;
    }
    if (typeof grid.jqGrid !== 'function') {
      throw new Error('当前表格不支持分页跳转');
    }
    grid.jqGrid('setGridParam', { page: expectedPage });
    grid.trigger('reloadGrid', [{ page: expectedPage }]);
    await waitFor(() => {
      const loadingNode = document.querySelector('#load_tempGrid, #lui_tempGrid');
      return getCurrentGridPage() === expectedPage && !isElementVisible(loadingNode);
    }, 15000, 250);
    await sleep(300);
  }

async function collectAllRowsAcrossPages() {
    const originalPage = getCurrentGridPage();
    const lastPage = getLastGridPage();
    const rowMap = new Map();
    for (let page = 1; page <= lastPage; page += 1) {
      await goToGridPage(page);
      const pageRows = getRows();
      for (const row of pageRows) {
        const taskKey = getRowTaskKey(row);
        if (!rowMap.has(taskKey)) {
          rowMap.set(taskKey, row);
        }
      }
    }
    await goToGridPage(originalPage);
    return Array.from(rowMap.values());
  }

function normalizeText(text) {
    return String(text || '').replace(/\s+/g, '');
  }

function isNeverSavedRow(row) {
    if (row && row.tjzt !== undefined && row.tjzt !== null && String(row.tjzt).trim() !== '') {
      return String(row.tjzt).trim() === '-1';
    }
    const statusText = normalizeText(row && row.tjztmc);
    return /未评/.test(statusText) && !/已评完/.test(statusText);
  }

function getCurrentEvaluationKey() {
    const currentBody = document.querySelector('.xspj-body[data-jxb_id]');
    if (!currentBody) {
      return '';
    }
    return currentBody.getAttribute('data-jxb_id') || '';
  }

function dispatchNativeEvent(element, type) {
    if (!element) {
      return;
    }
    element.dispatchEvent(new Event(type, { bubbles: true, cancelable: true }));
  }

function getReadyScoreRows() {
    return Array.from(document.querySelectorAll('tr.tr-xspj'));
  }

async function waitForEvaluationReady(timeoutMs = 15000) {
    return waitFor(() => {
      const loadingNode = document.querySelector('#loading_status');
      if (loadingNode) {
        return false;
      }
      const rowCount = document.querySelectorAll('tr.tr-xspj').length;
      const totalRadioCount = document.querySelectorAll('input.radio-pjf, tr.tr-xspj input[type="radio"]').length;
      return rowCount > 0 && totalRadioCount > 0 ? getReadyScoreRows() : false;
    }, timeoutMs, 250);
  }

async function selectRow(row) {
    const { $, grid } = getGridApi();
    const beforeKey = getCurrentEvaluationKey();
    const beforeSelectedRowId = getSelectedRowId();
    const targetRowId = String(row.__rowId);
    const targetEvaluationKey = String(row.jxb_id || '');

// #region debug-point A:select-row-start
    debugReport('A', '正方一键评价.user.js:selectRow', 'select row start', {
      targetRowId,
      targetEvaluationKey,
      beforeKey,
      beforeSelectedRowId,
      course: row.kcmc,
      teacher: row.jzgmc
    });
    // #endregion

// 正方实际切课逻辑在 onSelectRow 内部通过 panel_content.load 完成。
    // 直接走同一条 load 链，比模拟点击表格行更稳定。
    // #region debug-point A:select-row-load-target
    debugReport('A', '正方一键评价.user.js:selectRow', 'loading target row directly', {
      targetRowId,
      targetEvaluationKey
    });
    // #endregion

if (typeof window !== 'undefined') {
      try {
        window.select_id = targetRowId;
      } catch (error) {
        // ignore
      }
    }

const panelContent = $('#panel_content');
    const loadingHtml = '<p id="loading_status" class="text-center header smaller lighter" style="margin-top:150px;"><i class="icon-spinner icon-spin orange bigger-500"></i><br>加载中...</p>';
    panelContent.html(loadingHtml);
    $('#progress_loading').attr('aria-valuenow', 0).css('width', '0%');
    $('#btn_xspj_bc').removeClass('disabled').prop({ disabled: false });
    $('#btn_xspj_tj').removeClass('disabled').prop({ disabled: false });

await new Promise((resolve, reject) => {
      panelContent.load(`${window._path || ''}/xspjgl/xspj_cxXspjDisplay.html`, {
        jxb_id: row.jxb_id,
        kch_id: row.kch_id,
        xsdm: row.xsdm,
        jgh_id: row.jgh_id,
        tjzt: row.tjzt,
        pjmbmcb_id: row.pjmbmcb_id,
        sfcjlrjs: row.sfcjlrjs
      }, (responseText, textStatus) => {
        if (textStatus && textStatus !== 'success') {
          reject(new Error(`加载评价页面失败: ${textStatus}`));
          return;
        }
        if ($('#xxdm').val() === '10076') {
          $('#jsxm').text(`${$.founded(row.jgmc) ? row.jgmc : '无学院'}/${$.founded(row.zcmc) ? row.zcmc : '无职称'}/${row.jzgmc}`);
        } else {
          $('#jsxm').text(row.jzgmc || '');
        }
        $(panelContent).find('[data-toggle="tooltip"]').tooltip('destroy').tooltip({ container: panelContent });
        resolve();
      });
    });

// 必须等到真正的评价行渲染完成，不能只看高亮行
    await waitFor(() => {
      const loadingNode = document.querySelector('#loading_status');
      const rowCount = document.querySelectorAll('tr.tr-xspj').length;
      const totalRadioCount = document.querySelectorAll('input.radio-pjf, tr.tr-xspj input[type="radio"]').length;
      const currentEvaluationKey = getCurrentEvaluationKey();
      const keyMatched = !targetEvaluationKey || currentEvaluationKey === targetEvaluationKey;
      const ok = keyMatched && !loadingNode && rowCount > 0 && totalRadioCount > 0;
      // #region debug-point A:select-row-wait
      debugReport('A', '正方一键评价.user.js:selectRow', 'waiting check', {
        selectedRowId: getSelectedRowId(),
        targetRowId,
        currentEvaluationKey,
        targetEvaluationKey,
        keyMatched,
        radioCount: totalRadioCount,
        rowCount,
        hasLoadingNode: !!loadingNode,
        ok
      });
      // #endregion
      return ok;
    }, 15000, 300);

// 额外再等一小会儿，让页面完全渲染
    await sleep(800);

// #region debug-point A:select-row-done
    debugReport('A', '正方一键评价.user.js:selectRow', 'select row resolved', {
      targetRowId,
      afterKey: getCurrentEvaluationKey(),
      selectedRowId: getSelectedRowId(),
      radioCount: document.querySelectorAll('.radio-pjf').length
    });
    // #endregion
  }

function getSelectedRowId() {
    const selectedRow = document.querySelector('#tempGrid .ui-state-highlight, #tempGrid .success, #tempGrid tr[aria-selected="true"]');
    return selectedRow ? selectedRow.id : '';
  }

function pickRadioByScore(radios, expectedScore) {
    // #region debug-point B:pickRadio-start
    debugReport('B', '正方一键评价.user.js:pickRadioByScore', 'pick radio start', {
      expectedScore,
      radiosCount: radios.length,
      dyfValues: Array.from(radios).map((r) => ({
        dyf: r && r.dataset ? r.dataset.dyf : '',
        attr: r && r.getAttribute ? r.getAttribute('data-dyf') : '',
        value: r ? r.value : ''
      }))
    });
    // #endregion

if (!items.length) {
      items = [];
      for (let index = 0; index < radioList.length; index += 1) {
        const radio = radioList[index];
        items.push({
          element: radio,
          score: radioList.length - index,
          attrScore: radio && radio.getAttribute ? radio.getAttribute('data-dyf') : '',
          index
        });
      }
      // #region debug-point B:pickRadio-no-items
      debugReport('B', '正方一键评价.user.js:pickRadioByScore', 'fallback to index-based score ordering', { radiosCount: radios.length });
      // #endregion
    }

let picked;
    const exact = items.find((item) => String(item.attrScore) === String(expectedScore) || item.score === expectedScore);
    if (exact) {
      picked = exact.element;
    } else {
      const lower = items.find((item) => item.score <= expectedScore);
      if (lower) {
        picked = lower.element;
      } else {
        picked = items[0].element;
      }
    }

// #region debug-point B:pickRadio-picked
    debugReport('B', '正方一键评价.user.js:pickRadioByScore', 'picked radio', {
      expectedScore,
      pickedDyf: picked.dataset.dyf,
      pickedName: picked.name
    });
    // #endregion

return picked;
  }

function chooseScoreForRow(radios, config, rowTypeId, typeCounterMap) {
    const availableScores = getSortedScorePool(radios);
    if (!availableScores.length) {
      return Number(config.fixedScore) || 100;
    }

const currentIndex = typeCounterMap.get(rowTypeId) || 0;
    typeCounterMap.set(rowTypeId, currentIndex + 1);

if (config.scoreMode === 'fixed') {
      const fixedScore = Number(config.fixedScore);
      const exact = availableScores.find((score) => score === fixedScore);
      return exact || availableScores[0];
    }

const configuredScores = getScoreCandidates(config)
      .filter((score) => availableScores.includes(score));
    const pool = configuredScores.length ? configuredScores : availableScores;
    if (config.scoreMode === 'rotate') {
      return pool[currentIndex % pool.length];
    }
    return pool[Math.floor(Math.random() * pool.length)];
  }

function checkRadio(radio, $) {
    if (!radio) {
      // #region debug-point B:checkRadio-null
      debugReport('B', '正方一键评价.user.js:checkRadio', 'no radio to check', { radio });
      // #endregion
      return;
    }

const safeName = typeof CSS !== 'undefined' && CSS.escape ? CSS.escape(radio.name) : radio.name.replace(/"/g, '\\"');
    const sameNameRadios = document.querySelectorAll(`input[type="radio"][name="${safeName}"]`);
    // #region debug-point B:checkRadio-sameName
    debugReport('B', '正方一键评价.user.js:checkRadio', 'checking radio', {
      name: radio.name,
      dyf: radio.dataset.dyf,
      sameNameCount: sameNameRadios.length
    });
    // #endregion

sameNameRadios.forEach((item) => {
      item.checked = false;
      item.removeAttribute('checked');
      if ($) {
        $(item).prop('checked', false);
        $(item).removeAttr('checked');
      }
    });

radio.checked = true;
    radio.setAttribute('checked', 'checked');
    if ($) {
      $(radio).prop('checked', true);
      $(radio).attr('checked', 'checked');
    }

if ($) {
      $(radio).trigger('click');
      $(radio).trigger('input');
      $(radio).trigger('change');
    }

dispatchNativeEvent(radio, 'input');
    dispatchNativeEvent(radio, 'change');

const checkedRadio = document.querySelector(`input[type="radio"][name="${safeName}"]:checked`);
    // #region debug-point B:checkRadio-result
    debugReport('B', '正方一键评价.user.js:checkRadio', 'radio checked result', {
      radioChecked: radio.checked,
      radioPropChecked: $ ? $(radio).prop('checked') : 'no $',
      checkedDyfNow: checkedRadio ? checkedRadio.getAttribute('data-dyf') : '',
      checkedExistsNow: !!checkedRadio
    });
    // #endregion
  }

function fillCurrentEvaluation(config) {
    const $ = getPageJQuery();
    const currentKey = getCurrentEvaluationKey();
    // #region debug-point B:fill-start
    debugReport('B', '正方一键评价.user.js:fillCurrentEvaluation', 'fill start', { currentKey, config });
    // #endregion

if (!$) {
      throw new Error('页面 jQuery 不可用');
    }

if (!rowsWithRadios.length) {
      // #region debug-point B:fill-no-radio
      debugReport('B', '正方一键评价.user.js:fillCurrentEvaluation', 'no radio groups found', {
        rowCount: scoreRows.length,
        textareaCount: document.querySelectorAll('textarea.input-zgpj').length,
        currentKey: getCurrentEvaluationKey()
      });
      // #endregion
      throw new Error('当前课程还没加载完成');
    }

const teacherComments = splitLines(config.teacherComments);
    const courseComments = splitLines(config.courseComments);
    let commentCount = 0;

document.querySelectorAll('textarea.input-zgpj, textarea[name*="zgpj"], textarea[class*="zgpj"]').forEach((textarea, index) => {
      const panel = textarea.closest('.panel-pjdx');
      const targetType = panel ? String(panel.getAttribute('data-pjdxdm') || '') : '';
      const commentPool = targetType === '02' ? courseComments : teacherComments;
      const pickedComment = chooseFromList(commentPool, index, config.commentMode) || '整体体验很好，感谢老师的付出。';
      const finalComment = ensureCommentLength(pickedComment, textarea);
      textarea.value = finalComment;
      dispatchNativeEvent(textarea, 'input');
      dispatchNativeEvent(textarea, 'change');
      $(textarea).trigger('input');
      $(textarea).trigger('propertychange');
      $(textarea).trigger('change');
      commentCount += 1;
    });
    // #region debug-point B:comment-fill-summary
    debugReport('B', '正方一键评价.user.js:fillCurrentEvaluation', 'comment fill summary', {
      commentCount,
      teacherCommentPool: teacherComments.length,
      courseCommentPool: courseComments.length,
      currentKey: getCurrentEvaluationKey()
    });
    // #endregion
  }

const positivePatterns = /确定|确认|继续|提交|保存|是|ok|yes|完成/i;
    const negativePatterns = /取消|关闭|否|no/i;
    const preferred = buttons.find((button) => {
      const text = normalizeText(button.textContent || button.getAttribute('title') || '');
      return positivePatterns.test(text) && !negativePatterns.test(text);
    });
    return preferred || null;
  }

async function settleDialogs(config, maxWaitMs = 12000) {
    if (!config.autoConfirmDialog) {
      return;
    }
    const start = Date.now();
    let lastActionAt = Date.now();
    while (Date.now() - start < maxWaitMs) {
      const button = findDialogConfirmButton();
      if (button) {
        button.click();
        lastActionAt = Date.now();
        await sleep(config.dialogDelayMs);
        continue;
      }
      if (Date.now() - lastActionAt > 1200) {
        break;
      }
      await sleep(200);
    }
  }

async function processCurrent(action) {
    await ensureBlogVisited();
    const config = saveConfig(getCurrentConfigFromPanel());
    try {
      await waitForEvaluationReady();
      fillCurrentEvaluation(config);
      setStatus(action === 'save' ? '正在保存当前课程...' : '正在提交当前课程...');
      await sleep(180);
      triggerActionButton(action);
      await settleDialogs(config);
      await sleep(config.submitCooldownMs);
      setStatus(action === 'save' ? '当前课程已尝试保存' : '当前课程已尝试提交');
    } finally {
      state.blogVisitedForThisRun = false;
    }
  }

async function processBatch(action) {
    const config = saveConfig(getCurrentConfigFromPanel());
    state.running = true;
    state.stopRequested = false;
    state.lastBatchRowKey = '';
    state.sameRowRetry = 0;
    state.processedSaveRowKeys = new Set();
    state.lastCommentPickMap = new Map();

try {
      setStatus('正在扫描全部课程...');
      const allRows = await collectAllRowsAcrossPages();
      setTaskItems(allRows);

const candidates = [];
      for (const row of allRows) {
        if (!isSubmittedRow(row)) {
          candidates.push(row);
        }
      }

if (!candidates.length) {
        setStatus('全部课程都已经完成');
        return;
      }

for (let index = 0; index < candidates.length; index += 1) {
        if (state.stopRequested) {
          break;
        }
        const row = candidates[index];
        const currentKey = `${row.__rowId}__${row.jxb_id || ''}`;
        const taskKey = getRowTaskKey(row);
        const displayName = getRowDisplayName(row);
        updateTaskItem(taskKey, 'running', `处理中 ${index + 1}/${candidates.length}`);
        setStatus(`处理中 (${index + 1}/${candidates.length}): ${displayName}`);
        // #region debug-point E:batch-loop
        debugReport('E', '正方一键评价.user.js:processBatch', 'batch loop tick', {
          action,
          displayName,
          rowId: row.__rowId,
          jxbId: row.jxb_id,
          jghId: row.jgh_id,
          step: index + 1,
          remainingCandidates: candidates.length - index
        });
        // #endregion
        try {
          await selectRow(row);
          await sleep(config.switchDelayMs);
          await waitForEvaluationReady();
          fillCurrentEvaluation(config);
          await sleep(220);
          triggerActionButton(action);
          await settleDialogs(config);
          await sleep(config.submitCooldownMs);
          if (action === 'save') {
            state.processedSaveRowKeys.add(currentKey);
          }
          updateTaskItem(taskKey, 'done', action === 'save' ? '已保存' : '已提交');
        } catch (error) {
          updateTaskItem(taskKey, 'error', error.message || '处理失败');
          throw new Error(`${displayName} 处理失败：${error.message || '未知错误'}`);
        }
      }

if (state.stopRequested) {
        setStatus('批量任务已停止');
        return;
      }

setStatus(action === 'save' ? '批量保存完成' : '批量提交完成');
    } finally {
      state.running = false;
      state.blogVisitedForThisRun = false;
    }
  }

async function bootstrap() {
    await waitFor(() => isReady(), 15000, 250);
    createPanel();
    registerMenu();
    setStatus('已就绪，先点“保存配置”再使用更稳');
  }

bootstrap().catch((error) => {
    console.error('[正方一键评价] 初始化失败', error);
  });
})();
```

最后修改：2026 年 07 月 02 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

一键教师好评脚本及在线网站

lminyo • 2026 年 07 月 02 日