精确计算各星级评价数量及提升评分所需五星好评数，支持全球亚马逊站点
目前为
// ==UserScript==
// @name 亚马逊评论计算优化版(Enhanced Amazon Review Calculator)
// @namespace https://github.com/monty8800/amazon-seller-tools
// @version 3.2
// @description 精确计算各星级评价数量及提升评分所需五星好评数，支持全球亚马逊站点
// @author Monty & Assistant
// @match *://*.amazon.com/*dp/*
// @match *://*.amazon.co.uk/*dp/*
// @match *://*.amazon.de/*dp/*
// @match *://*.amazon.fr/*dp/*
// @match *://*.amazon.it/*dp/*
// @match *://*.amazon.es/*dp/*
// @match *://*.amazon.co.jp/*dp/*
// @match *://*.amazon.ca/*dp/*
// @match *://*.amazon.com.au/*dp/*
// @match *://*.amazon.in/*dp/*
// @match *://*.amazon.com.mx/*dp/*
// @match *://*.amazon.com.br/*dp/*
// @match *://*.amazon.nl/*dp/*
// @match *://*.amazon.cn/*dp/*
// @match *://*.amazon.sg/*dp/*
// @match *://*.amazon.ae/*dp/*
// @match *://*.amazon.sa/*dp/*
// @match *://*.amzn.*/*dp/*
// @icon https://www.amazon.com/favicon.ico
// @grant GM_getValue
// @grant GM_setValue
// @grant GM_addStyle
// @license MIT
// ==/UserScript==
GM_addStyle(`
.monty-review-box {
border: 1px solid #ddd;
padding: 12px;
margin: 10px 0;
background: #f8f8f8;
border-radius: 4px;
}
.monty-review-title {
font-weight: bold;
color: #111;
margin-bottom: 8px;
display: flex;
justify-content: space-between;
align-items: center;
}
.monty-review-item {
margin: 4px 0;
font-size: 13px;
}
.monty-highlight {
color: #B12704;
font-weight: bold;
}
.monty-lang-selector {
font-size: 12px;
padding: 2px 5px;
border: 1px solid #ddd;
border-radius: 3px;
background: white;
cursor: pointer;
}
.monty-lang-selector:hover {
border-color: #aaa;
}
`);
(function() {
'use strict';
const TARGET_SCORE = 4.3;
const DEBUG_MODE = true; // 生产环境中关闭调试模式
// 日志输出函数
function log(...args) {
if (DEBUG_MODE) {
console.log('[Review Calculator]', ...args);
}
}
// 获取用户语言偏好
function getUserLanguage() {
// 获取用户保存的语言偏好，默认为中文
const savedLanguage = GM_getValue('user_language', 'zh');
log('用户语言偏好:', savedLanguage);
return savedLanguage;
}
// 设置用户语言偏好
function setUserLanguage(language) {
log('设置用户语言偏好:', language);
GM_setValue('user_language', language);
}
// 获取本地化文本
function getLocalizedText() {
// 优先使用用户选择的语言
const userLanguage = getUserLanguage();
// 如果没有用户选择的语言，则根据域名自动检测
if (!userLanguage || userLanguage === 'auto') {
const domain = window.location.hostname;
log('当前域名:', domain);
// 根据域名确定语言
let detectedLanguage = 'en'; // 默认英语
if (domain.includes('.fr')) detectedLanguage = 'fr';
else if (domain.includes('.de')) detectedLanguage = 'de';
else if (domain.includes('.it')) detectedLanguage = 'it';
else if (domain.includes('.es')) detectedLanguage = 'es';
else if (domain.includes('.co.jp') || domain.includes('.jp')) detectedLanguage = 'jp';
else if (domain.includes('.cn')) detectedLanguage = 'zh';
else if (domain.includes('.nl')) detectedLanguage = 'nl';
else if (domain.includes('.com.br')) detectedLanguage = 'pt-br';
else if (domain.includes('.com.mx')) detectedLanguage = 'es-mx';
else if (domain.includes('.in')) detectedLanguage = 'en-in';
else if (domain.includes('.ca')) detectedLanguage = domain.includes('/fr/') ? 'fr-ca' : 'en-ca';
log('检测到语言:', detectedLanguage);
return getLocalizedTextByLanguage(detectedLanguage);
}
return getLocalizedTextByLanguage(userLanguage);
}
// 根据指定语言获取本地化文本
function getLocalizedTextByLanguage(language) {
log('使用语言:', language);
// 各种语言的本地化文本
const localizedTexts = {
// 评论数文本
ratingsText: {
'en': 'ratings',
'fr': 'évaluations',
'de': 'Bewertungen',
'it': 'recensioni',
'es': 'valoraciones',
'es-mx': 'calificaciones',
'jp': '件の評価',
'zh': '条评论',
'nl': 'beoordelingen',
'pt-br': 'avaliações',
'en-in': 'ratings',
'en-ca': 'ratings',
'fr-ca': 'évaluations'
},
// 星级文本 (用于匹配评分文本)
starText: {
'en': 'out of 5 stars',
'fr': 'sur 5 étoiles',
'de': 'von 5 Sternen',
'it': 'su 5 stelle',
'es': 'de 5 estrellas',
'es-mx': 'de 5 estrellas',
'jp': '5つ星のうち',
'zh': '5 星，最多 5 星',
'nl': 'van de 5 sterren',
'pt-br': 'de 5 estrelas',
'en-in': 'out of 5 stars',
'en-ca': 'out of 5 stars',
'fr-ca': 'sur 5 étoiles'
},
// 结果面板文本
resultText: {
'en': {
title: '📊 Review Analysis',
currentScore: 'Current Rating:',
required: 'Need',
fiveStarReviews: '5-star reviews',
toReach: 'to reach',
noNeed: 'Current rating already exceeds',
noNeedSuffix: ', no additional reviews needed',
simplified: '(Simplified)',
note: 'Note: This is a simplified result due to inability to get detailed rating data',
error: '⚠️ Review Calculator encountered an issue',
errorHelp: 'If the problem persists, try refreshing the page or check for script updates.'
},
'fr': {
title: '📊 Analyse des Avis',
currentScore: 'Note actuelle:',
required: 'Besoin de',
fiveStarReviews: 'avis 5 étoiles',
toReach: 'pour atteindre',
noNeed: 'La note actuelle dépasse déjà',
noNeedSuffix: ', aucun avis supplémentaire nécessaire',
simplified: '(Simplifié)',
note: 'Remarque: Il s\'agit d\'un résultat simplifié en raison de l\'impossibilité d\'obtenir des données d\'évaluation détaillées',
error: '⚠️ Le calculateur d\'avis a rencontré un problème',
errorHelp: 'Si le problème persiste, essayez d\'actualiser la page ou vérifiez les mises à jour du script.'
},
'de': {
title: '📊 Bewertungsanalyse',
currentScore: 'Aktuelle Bewertung:',
required: 'Benötigt',
fiveStarReviews: '5-Sterne-Bewertungen',
toReach: 'um zu erreichen',
noNeed: 'Aktuelle Bewertung überschreitet bereits',
noNeedSuffix: ', keine zusätzlichen Bewertungen erforderlich',
simplified: '(Vereinfacht)',
note: 'Hinweis: Dies ist ein vereinfachtes Ergebnis, da detaillierte Bewertungsdaten nicht verfügbar sind',
error: '⚠️ Der Bewertungsrechner ist auf ein Problem gestoßen',
errorHelp: 'Wenn das Problem weiterhin besteht, aktualisieren Sie die Seite oder prüfen Sie auf Skript-Updates.'
},
'zh': {
title: '📊 评论分析结果',
currentScore: '当前评分：',
required: '需要',
fiveStarReviews: '个五星好评',
toReach: '才能达到',
noNeed: '当前评分已超过',
noNeedSuffix: '，无需补充好评',
simplified: '(简化版)',
note: '注意：由于无法获取详细评分数据，此结果为简化版',
error: '⚠️ 评论计算器遇到问题',
errorHelp: '如果问题持续存在，请尝试刷新页面或检查脚本更新。'
},
'jp': {
title: '📊 レビュー分析',
currentScore: '現在の評価：',
required: '',
fiveStarReviews: '件の5つ星レビューが必要',
toReach: 'で到達するために',
noNeed: '現在の評価はすでに',
noNeedSuffix: 'を超えています、追加のレビューは必要ありません',
simplified: '(簡易版)',
note: '注意：詳細な評価データを取得できないため、これは簡易結果です',
error: '⚠️ レビュー計算ツールで問題が発生しました',
errorHelp: '問題が解決しない場合は、ページを更新するかスクリプトの更新を確認してください。'
}
// 可以根据需要添加更多语言
}
};
// 如果没有特定语言的翻译，使用英语作为后备
const getTextWithFallback = (category, lang) => {
return localizedTexts[category][lang] || localizedTexts[category]['en'];
};
return {
ratingsText: getTextWithFallback('ratingsText', language),
starText: getTextWithFallback('starText', language),
resultText: localizedTexts.resultText[language] || localizedTexts.resultText['en']
};
}
// 清洗数字格式（处理千位分隔符）
function sanitizeNumber(numStr) {
return numStr.replace(/[.,\s]/g, '')
.replace(/[^\d]/g, '');
}
// 计算加权平均分
function calculateWeightedAverage(ratings) {
const total = ratings.reduce((sum, r) => sum + r.count, 0);
if (total === 0) return 0;
return ratings.reduce((sum, r) => {
return sum + (r.stars * r.count);
}, 0) / total;
}
// 计算所需五星好评
function calculateRequiredReviews(currentScore, totalReviews) {
if (currentScore >= TARGET_SCORE) return 0;
const numerator = totalReviews * (TARGET_SCORE - currentScore);
const denominator = 5 - TARGET_SCORE;
return Math.ceil(numerator / denominator);
}
// 主处理函数
async function processReviews() {
try {
log('开始处理评论数据...');
log('当前URL:', window.location.href);
// 等待评分直方图加载 - 使用最新的选择器
log('等待评分直方图加载...');
const histogram = await waitForElement('#histogramTable');
if (!histogram) {
log('错误: 找不到评分直方图');
throw new Error('找不到评分直方图');
}
log('成功找到评分直方图:', histogram);
// 获取本地化文本
const localizedText = getLocalizedText();
log('本地化文本:', localizedText);
// 直接使用data-hook属性查找总评论数
const totalElement = document.querySelector('[data-hook="total-review-count"]');
log('总评论数元素:', totalElement);
if (!totalElement) {
log('错误: 找不到总评论数元素');
throw new Error('找不到总评论数元素');
}
log('总评论数文本:', totalElement.textContent);
const totalReviews = parseInt(sanitizeNumber(totalElement.textContent));
log('解析后的总评论数:', totalReviews);
if (isNaN(totalReviews)) {
log('错误: 总评论数格式错误');
throw new Error('总评论数格式错误');
}
// 获取各星级评价 - 使用最新的选择器
log('查找评分条...');
const ratingBars = [...document.querySelectorAll('#histogramTable li a')];
log('找到评分条数量:', ratingBars.length);
if (ratingBars.length !== 5) {
log('错误: 找不到完整的五星评价数据, 只找到', ratingBars.length, '条');
throw new Error('找不到完整的五星评价数据');
}
log('开始提取各星级评价数据...');
const ratings = ratingBars.map((bar, index) => {
// 获取星级 (5星到1星)
const stars = 5 - index;
log(`处理 ${stars} 星评价...`);
// 获取百分比 - 从aria-valuenow属性获取
let percent = 0;
const meter = bar.querySelector('.a-meter');
log(`${stars}星评价条元素:`, meter);
if (meter && meter.getAttribute('aria-valuenow')) {
percent = parseInt(meter.getAttribute('aria-valuenow')) / 100;
log(`${stars}星评价 - 从aria-valuenow获取百分比:`, percent);
}
// 如果无法从aria-valuenow获取，尝试从style.width获取
if (percent === 0 && meter && meter.querySelector('.a-meter-bar')) {
const meterBar = meter.querySelector('.a-meter-bar');
const widthStyle = meterBar.style.width;
log(`${stars}星评价 - meter-bar宽度样式:`, widthStyle);
if (widthStyle) {
percent = parseInt(widthStyle) / 100;
log(`${stars}星评价 - 从style.width获取百分比:`, percent);
}
}
// 如果仍然无法获取百分比，尝试从文本中提取
if (percent === 0) {
log(`${stars}星评价 - 尝试从文本提取百分比...`);
const percentTexts = bar.querySelectorAll('.a-text-right, .aok-nowrap');
log(`${stars}星评价 - 找到可能包含百分比的文本元素:`, percentTexts.length);
for (const el of percentTexts) {
log(`${stars}星评价 - 文本内容:`, el.textContent);
const percentMatch = el.textContent.match(/(\d+)%/);
if (percentMatch) {
percent = parseInt(percentMatch[1]) / 100;
log(`${stars}星评价 - 从文本提取的百分比:`, percent);
break;
}
}
}
const count = Math.round(totalReviews * percent);
log(`${stars}星评价 - 最终数据:`, { stars, percent, count });
return {
stars: stars,
percent: percent,
count: count
};
});
// 计算当前评分
log('计算加权平均分...');
const currentScore = calculateWeightedAverage(ratings);
log('计算得到的当前评分:', currentScore);
// 计算结果
log('计算所需五星好评数...');
const required = calculateRequiredReviews(currentScore, totalReviews);
log('需要的五星好评数:', required);
// 生成结果面板
const resultBox = document.createElement('div');
resultBox.className = 'monty-review-box';
resultBox.id = 'monty-review-box';
// 使用本地化文本
const rt = localizedText.resultText;
// 创建语言选择器
const currentLang = getUserLanguage();
const langOptions = {
'zh': '中文',
'en': 'English',
'fr': 'Français',
'de': 'Deutsch',
'jp': '日本語'
};
const langSelector = `
<select class="monty-lang-selector" id="monty-lang-selector">
${Object.entries(langOptions).map(([code, name]) =>
`<option value="${code}" ${code === currentLang ? 'selected' : ''}>${name}</option>`
).join('')}
</select>
`;
resultBox.innerHTML = `
<div class="monty-review-title">
<span>${rt.title}</span>
${langSelector}
</div>
${ratings.map(r => `
<div class="monty-review-item">
${'★'.repeat(r.stars)} ${r.count} (${(r.percent*100).toFixed(1)}%)
</div>
`).join('')}
<hr style="margin:8px 0">
<div class="monty-review-item">
${rt.currentScore} <span class="monty-highlight">${currentScore.toFixed(2)}</span>
</div>
${required > 0 ? `
<div class="monty-review-item">
${rt.required} <span class="monty-highlight">${required} ${rt.fiveStarReviews}</span>
${rt.toReach} ${TARGET_SCORE}
</div>
` : `
<div class="monty-review-item monty-highlight">
${rt.noNeed} ${TARGET_SCORE}${rt.noNeedSuffix}
</div>
`}
`;
// 保存评分数据，以便在切换语言时重新生成结果面板
resultBox.dataset.currentScore = currentScore;
resultBox.dataset.totalReviews = totalReviews;
resultBox.dataset.required = required;
resultBox.dataset.ratingsData = JSON.stringify(ratings);
// 插入结果到页面 - 使用更准确的插入点
log('准备插入结果面板到页面...');
const possibleInsertPoints = [
'#averageCustomerReviews',
'#histogramTable',
'[data-hook="cr-filter-info-review-rating-count"]',
'.cr-widget-histogram'
];
log('尝试以下插入点:', possibleInsertPoints);
let inserted = false;
for (const selector of possibleInsertPoints) {
const insertPoint = document.querySelector(selector);
log(`检查插入点 ${selector}:`, insertPoint ? '找到' : '未找到');
if (insertPoint) {
// 尝试插入到元素之后
if (insertPoint.parentNode) {
log(`将结果面板插入到 ${selector} 之后`);
insertPoint.parentNode.insertBefore(resultBox, insertPoint.nextSibling);
inserted = true;
break;
}
}
}
// 如果无法找到合适的插入点，则插入到直方图之前
if (!inserted) {
log('未找到理想插入点，尝试使用直方图作为插入点');
if (histogram && histogram.parentNode) {
log('将结果面板插入到直方图之前');
histogram.parentNode.insertBefore(resultBox, histogram);
inserted = true;
} else {
log('警告: 无法找到任何插入点');
}
}
log('结果面板插入' + (inserted ? '成功' : '失败'));
// 添加语言选择器的事件监听器
if (inserted) {
const langSelector = document.getElementById('monty-lang-selector');
if (langSelector) {
langSelector.addEventListener('change', function() {
const newLang = this.value;
log('切换语言到:', newLang);
setUserLanguage(newLang);
// 重新生成结果面板
regenerateResultPanel(resultBox);
});
}
}
// 重新生成结果面板的函数
function regenerateResultPanel(panel) {
if (!panel) return;
// 获取保存的数据
const currentScore = parseFloat(panel.dataset.currentScore);
const totalReviews = parseInt(panel.dataset.totalReviews);
const required = parseInt(panel.dataset.required);
const ratings = JSON.parse(panel.dataset.ratingsData);
// 获取新的本地化文本
const localizedText = getLocalizedText();
const rt = localizedText.resultText;
// 创建语言选择器
const currentLang = getUserLanguage();
const langOptions = {
'zh': '中文',
'en': 'English',
'fr': 'Français',
'de': 'Deutsch',
'jp': '日本語'
};
const langSelector = `
<select class="monty-lang-selector" id="monty-lang-selector">
${Object.entries(langOptions).map(([code, name]) =>
`<option value="${code}" ${code === currentLang ? 'selected' : ''}>${name}</option>`
).join('')}
</select>
`;
// 更新面板内容
panel.innerHTML = `
<div class="monty-review-title">
<span>${rt.title}</span>
${langSelector}
</div>
${ratings.map(r => `
<div class="monty-review-item">
${'★'.repeat(r.stars)} ${r.count} (${(r.percent*100).toFixed(1)}%)
</div>
`).join('')}
<hr style="margin:8px 0">
<div class="monty-review-item">
${rt.currentScore} <span class="monty-highlight">${currentScore.toFixed(2)}</span>
</div>
${required > 0 ? `
<div class="monty-review-item">
${rt.required} <span class="monty-highlight">${required} ${rt.fiveStarReviews}</span>
${rt.toReach} ${TARGET_SCORE}
</div>
` : `
<div class="monty-review-item monty-highlight">
${rt.noNeed} ${TARGET_SCORE}${rt.noNeedSuffix}
</div>
`}
<div class="monty-review-item" style="font-size: 11px; margin-top: 8px; text-align: right;">
© 2025 Monty Ng. All rights reserved.
</div>
`;
// 重新添加事件监听器
const newLangSelector = document.getElementById('monty-lang-selector');
if (newLangSelector) {
newLangSelector.addEventListener('change', function() {
const newLang = this.value;
log('切换语言到:', newLang);
setUserLanguage(newLang);
// 重新生成结果面板
regenerateResultPanel(panel);
});
}
}
} catch (error) {
if (DEBUG_MODE) console.error('[Review Calculator]', error);
// 在页面上显示错误信息，帮助用户理解问题
showError(`计算评论数据时出错: ${error.message}`);
// 尝试使用备用方法获取评分
log('主方法失败，尝试使用备用方法...');
try {
// 尝试从页面上直接获取平均评分
log('尝试从页面直接获取平均评分...');
const ratingElement = document.querySelector('[data-hook="average-star-rating"] .a-icon-alt');
log('评分元素:', ratingElement);
if (ratingElement) {
log('评分文本:', ratingElement.textContent);
const ratingMatch = ratingElement.textContent.match(/(\d+(\.\d+)?)/);
log('评分匹配结果:', ratingMatch);
if (ratingMatch) {
const currentScore = parseFloat(ratingMatch[1]);
log('解析后的评分:', currentScore);
// 尝试获取总评论数
log('尝试获取总评论数...');
const totalElement = document.querySelector('[data-hook="total-review-count"]');
log('总评论数元素:', totalElement);
if (totalElement) {
log('总评论数文本:', totalElement.textContent);
const totalReviews = parseInt(sanitizeNumber(totalElement.textContent));
log('解析后的总评论数:', totalReviews);
if (!isNaN(totalReviews) && !isNaN(currentScore)) {
log('成功获取评分和总评论数，计算所需五星好评...');
// 计算所需五星好评
const required = calculateRequiredReviews(currentScore, totalReviews);
log('需要的五星好评数:', required);
// 获取本地化文本
const localizedText = getLocalizedText();
const rt = localizedText.resultText;
// 创建简化版结果面板
log('创建简化版结果面板...');
const simpleBox = document.createElement('div');
simpleBox.className = 'monty-review-box';
simpleBox.id = 'monty-simple-review-box';
// 创建语言选择器
const currentLang = getUserLanguage();
const langOptions = {
'zh': '中文',
'en': 'English',
'fr': 'Français',
'de': 'Deutsch',
'jp': '日本語'
};
const langSelector = `
<select class="monty-lang-selector" id="monty-simple-lang-selector">
${Object.entries(langOptions).map(([code, name]) =>
`<option value="${code}" ${code === currentLang ? 'selected' : ''}>${name}</option>`
).join('')}
</select>
`;
simpleBox.innerHTML = `
<div class="monty-review-title">
<span>${rt.title} ${rt.simplified}</span>
${langSelector}
</div>
<div class="monty-review-item">
${rt.currentScore} <span class="monty-highlight">${currentScore.toFixed(2)}</span>
</div>
${required > 0 ? `
<div class="monty-review-item">
${rt.required} <span class="monty-highlight">${required} ${rt.fiveStarReviews}</span>
${rt.toReach} ${TARGET_SCORE}
</div>
` : `
<div class="monty-review-item monty-highlight">
${rt.noNeed} ${TARGET_SCORE}${rt.noNeedSuffix}
</div>
`}
<div class="monty-review-item">
<small>${rt.note}</small>
</div>
`;
// 保存评分数据，以便在切换语言时重新生成结果面板
simpleBox.dataset.currentScore = currentScore;
simpleBox.dataset.totalReviews = totalReviews;
simpleBox.dataset.required = required;
// 尝试插入到页面
log('尝试插入简化版结果面板...');
const insertPoint = document.querySelector('#averageCustomerReviews');
log('插入点:', insertPoint);
if (insertPoint && insertPoint.parentNode) {
log('将简化版结果面板插入到页面');
insertPoint.parentNode.insertBefore(simpleBox, insertPoint.nextSibling);
log('简化版结果面板插入成功');
// 添加语言选择器的事件监听器
const simpleLangSelector = document.getElementById('monty-simple-lang-selector');
if (simpleLangSelector) {
simpleLangSelector.addEventListener('change', function() {
const newLang = this.value;
log('切换语言到:', newLang);
setUserLanguage(newLang);
// 重新生成简化版结果面板
regenerateSimpleResultPanel(simpleBox);
});
}
} else {
log('警告: 无法找到插入点');
}
// 重新生成简化版结果面板的函数
function regenerateSimpleResultPanel(panel) {
if (!panel) return;
// 获取保存的数据
const currentScore = parseFloat(panel.dataset.currentScore);
const totalReviews = parseInt(panel.dataset.totalReviews);
const required = parseInt(panel.dataset.required);
// 获取新的本地化文本
const localizedText = getLocalizedText();
const rt = localizedText.resultText;
// 创建语言选择器
const currentLang = getUserLanguage();
const langOptions = {
'zh': '中文',
'en': 'English',
'fr': 'Français',
'de': 'Deutsch',
'jp': '日本語'
};
const langSelector = `
<select class="monty-lang-selector" id="monty-simple-lang-selector">
${Object.entries(langOptions).map(([code, name]) =>
`<option value="${code}" ${code === currentLang ? 'selected' : ''}>${name}</option>`
).join('')}
</select>
`;
// 更新面板内容
panel.innerHTML = `
<div class="monty-review-title">
<span>${rt.title} ${rt.simplified}</span>
${langSelector}
</div>
<div class="monty-review-item">
${rt.currentScore} <span class="monty-highlight">${currentScore.toFixed(2)}</span>
</div>
${required > 0 ? `
<div class="monty-review-item">
${rt.required} <span class="monty-highlight">${required} ${rt.fiveStarReviews}</span>
${rt.toReach} ${TARGET_SCORE}
</div>
` : `
<div class="monty-review-item monty-highlight">
${rt.noNeed} ${TARGET_SCORE}${rt.noNeedSuffix}
</div>
`}
<div class="monty-review-item">
<small>${rt.note}</small>
</div>
<div class="monty-review-item" style="font-size: 11px; margin-top: 8px; text-align: right;">
© 2025 Monty Ng. All rights reserved.
</div>
`;
// 重新添加事件监听器
const newLangSelector = document.getElementById('monty-simple-lang-selector');
if (newLangSelector) {
newLangSelector.addEventListener('change', function() {
const newLang = this.value;
log('切换语言到:', newLang);
setUserLanguage(newLang);
// 重新生成简化版结果面板
regenerateSimpleResultPanel(panel);
});
}
}
} else {
log('错误: 无效的评分或总评论数');
}
} else {
log('错误: 找不到总评论数元素');
}
} else {
log('错误: 无法从文本中提取评分');
}
} else {
log('错误: 找不到评分元素');
}
} catch (backupError) {
log('备用方法也失败:', backupError);
if (DEBUG_MODE) console.error('[Review Calculator] 备用方法也失败:', backupError);
}
}
}
// 辅助函数：等待元素加载
function waitForElement(selector, timeout = 5000) {
return new Promise((resolve) => {
// 如果元素已存在，立即返回
const existingEl = document.querySelector(selector);
if (existingEl) return resolve(existingEl);
// 否则，设置观察器等待元素出现
const start = Date.now();
// 创建一个MutationObserver来监视DOM变化
const observer = new MutationObserver(() => {
const el = document.querySelector(selector);
if (el) {
observer.disconnect(); // 停止观察
return resolve(el);
}
// 超时检查
if (Date.now() - start > timeout) {
observer.disconnect();
return resolve(null);
}
});
// 开始观察DOM变化
observer.observe(document.body, {
childList: true,
subtree: true
});
// 额外的超时保障
setTimeout(() => {
observer.disconnect();
resolve(document.querySelector(selector));
}, timeout);
});
}
// 显示错误信息
function showError(message) {
if (DEBUG_MODE) console.error('[Review Calculator]', message);
// 获取本地化文本
const localizedText = getLocalizedText();
const rt = localizedText.resultText;
// 在页面上显示错误信息
const errorBox = document.createElement('div');
errorBox.className = 'monty-review-box';
errorBox.innerHTML = `
<div class="monty-review-title">${rt.error}</div>
<div class="monty-review-item">${message}</div>
<div class="monty-review-item">
<small>${rt.errorHelp}</small>
</div>
<div class="monty-review-item" style="font-size: 11px; margin-top: 8px; text-align: right;">
© 2025 Monty Ng. All rights reserved.
</div>
`;
// 尝试插入到评论区域
const insertPoints = [
'#cm_cr-review_list',
'.cr-widget-histogram',
'#histogramTable',
'#averageCustomerReviews',
'#reviewsMedley'
];
for (const selector of insertPoints) {
const element = document.querySelector(selector);
if (element) {
element.parentNode.insertBefore(errorBox, element);
return;
}
}
// 如果找不到合适的插入点，插入到页面底部
document.body.appendChild(errorBox);
}
// 初始化
function init() {
log('初始化脚本...');
log('目标评分:', TARGET_SCORE);
GM_setValue('target_score', TARGET_SCORE);
// 确保我们在产品页面上
log('当前页面路径:', window.location.pathname);
if (!window.location.pathname.includes('/dp/')) {
log('不是产品页面，脚本不执行');
return;
}
// 等待DOM完全加载
log('当前文档状态:', document.readyState);
if (document.readyState === 'loading') {
log('文档仍在加载中，等待DOMContentLoaded事件...');
document.addEventListener('DOMContentLoaded', () => {
log('DOM已加载，延迟1500ms执行主函数');
setTimeout(processReviews, 1500);
});
} else {
// 如果DOM已加载，给页面一些时间来完成动态内容加载
log('DOM已加载，延迟1500ms执行主函数');
setTimeout(processReviews, 1500);
}
}
// 启动脚本
try {
log('脚本开始执行...');
log('浏览器信息:', navigator.userAgent);
init();
} catch (error) {
log('初始化失败:', error);
showError(`初始化失败: ${error.message}`);
}
})();