汇率获取中...
`;
} else {
const formattedRate = FormatRate(finalRate);
contentEl.innerHTML = `
${rateSource}
1 ${currency.Type} = ${formattedRate} CNY
${rateChangeHtml}
`;
}
}
function FormatRate(rate) {
// 处理0值特殊情况
if (rate === 0) return '0';
// 转换为字符串，避免科学计数法（针对极小值）
let rateStr = rate.toString();
// 若包含科学计数法（如1e-5），转换为普通字符串
if (rateStr.includes('e')) {
const parts = rateStr.split('e');
const base = parseFloat(parts[0]);
const exponent = parseInt(parts[1], 10);
// 处理负指数（小数）
if (exponent < 0) {
rateStr = '0.' + '0'.repeat(-exponent - 1) + base.toString().replace('.', '');
}
}
// 分离整数和小数部分
const [integerPart, decimalPart] = rateStr.split('.').concat(''); // 确保小数部分存在（空字符串）
// 情况1：无小数部分（整数）
if (!decimalPart) return integerPart;
// 情况2：有小数部分，处理尾随零
const trimmedDecimal = decimalPart.replace(/0+$/, ''); // 去掉末尾所有零
if (!trimmedDecimal) return integerPart; // 若小数部分全是零，只返回整数
// 情况3：根据数值大小动态调整显示位数
const absRate = Math.abs(rate);
let maxDecimalDigits;
if (absRate >= 1) {
// 大汇率（如USD 7.14）：最多保留4位，最少保留2位（避免1位小数）
maxDecimalDigits = Math.max(2, Math.min(4, trimmedDecimal.length));
} else if (absRate >= 0.01) {
// 中等小数（如0.52）：最多保留4位
maxDecimalDigits = 4;
} else {
// 极小汇率（如ARS 0.00525）：找到第一个非零数字后保留4位有效数字
const firstNonZeroIndex = trimmedDecimal.search(/[1-9]/);
if (firstNonZeroIndex === -1) return '0'; // 理论上不会触发
// 第一个非零数字位置 + 4位有效数字
maxDecimalDigits = firstNonZeroIndex + 5; // +5是因为索引从0开始
}
// 截取有效位数（不超过实际小数长度）
const finalDecimal = trimmedDecimal.slice(0, Math.min(maxDecimalDigits, trimmedDecimal.length));
return `${integerPart}.${finalDecimal}`;
}
function init() {
console.log('=== WG商店货币转换器-初始化开始 ===');
AddStyles();
createFloatPanel();
ConvertPageCurrencyValues();
ObserveDOMChanges();
console.log('=== WG商店货币转换器-初始化完成 ===');
}
function AddStyles() {
const style = document.createElement('style');
style.textContent = CONFIG.highlightStyle;
document.head.insertBefore(style, document.head.firstChild);
console.log('=== WG商店货币转换器-样式已添加 ===');
}
function ExtractCurrencyInfo(element) {
if (processedElements.has(element) || element.closest('#currency-float-panel')) {
return [null, null, null];
}
const priceWrap = element.querySelector('.product-price_wrap');
const text = priceWrap ? priceWrap.textContent.trim() : element.textContent.trim();
console.log(`[提取信息] 元素文本: ${text.substring(0, 50)}...`); // 限制长度，避免日志过长
// 1. 处理Symbol类型（如EUR/USD）
const currencyCodeEl = element.querySelector('.currency-code');
if (currencyCodeEl) {
const title = currencyCodeEl.getAttribute('title')?.trim();
console.log(`[提取信息] 找到.currency-code，title: ${title}`);
if (title) {
const targetCurrency = CurrencyDict.find(c => c.Symbol === title);
if (targetCurrency) {
const priceMatch = text.match(/(\d{1,3}(?:,\d{3})*(?:\.\d+)?)/);
console.log(`[提取信息] 价格匹配: ${priceMatch?.[1] || '无'}`);
if (priceMatch) {
const numericValue = parseFloat(priceMatch[1].replace(/,/g, ''));
if (!isNaN(numericValue)) {
console.log(`[提取成功] ${title} 数值: ${numericValue}`);
currentActiveCurrency = targetCurrency;
return [numericValue, title, targetCurrency];
}
}
}
}
}
// 2. 处理正则匹配类型（如ARS）
for (let currency of CurrencyDict) {
if (!currency.MatchRegex) continue;
const match = text.match(currency.MatchRegex);
if (match && match[1]) {
console.log(`[提取信息] 正则匹配 ${currency.Type}: ${match[1]}`);
const numericValue = parseFloat(match[1].replace(/,/g, ''));
if (!isNaN(numericValue)) {
console.log(`[提取成功] ${currency.Type} 数值: ${numericValue}`);
currentActiveCurrency = currency;
return [numericValue, currency.Type, currency];
}
}
}
console.log(`[提取失败] 元素不含目标货币`);
return [null, null, null];
}
function FindPriceElements() {
const validElements = [];
const allPriceEls = document.querySelectorAll('.product-price:not(.currency-processed)');
console.log(`[查找元素] 找到${allPriceEls.length}个未处理.product-price`);
allPriceEls.forEach(el => {
const [_, __, targetCurrency] = ExtractCurrencyInfo(el);
if (targetCurrency && !processedElements.has(el)) {
validElements.push(el);
console.log(`[查找元素] 加入有效元素列表`);
}
});
console.log(`[查找元素] 有效元素总数: ${validElements.length}`);
return validElements;
}
function FormatCurrency(value, currencyType) {
const targetCurrency = CurrencyDict.find(c => c.Type === currencyType);
if (!targetCurrency) {
console.warn(`[格式化] 未知货币类型: ${currencyType}`);
return `${value.toFixed(2)} (未知货币)`;
}
const finalRate = targetCurrency.getFinalRate();
const originalCNY = (value * finalRate).toFixed(2);
const discountedCNY = (originalCNY * CONFIG.discount).toFixed(2);
console.log(`[格式化] ${value} ${currencyType} → 原始: ${originalCNY} CNY, 折扣后: ${discountedCNY} CNY`);
return `${originalCNY} (${discountedCNY}) CNY`;
}
function ProcessPriceElement(element, currencyType) {
if (element.classList.contains('currency-processed') || processedElements.has(element)) {
console.log(`[处理元素] 已处理，跳过`);
return;
}
const [priceValue, _, targetCurrency] = ExtractCurrencyInfo(element);
if (!priceValue || !targetCurrency) {
console.log(`[处理元素] 无效价格或货币，跳过`);
return;
}
try {
const formattedCNY = FormatCurrency(priceValue, currencyType);
const conversionEl = document.createElement('span');
conversionEl.className = 'currency-conversion';
conversionEl.textContent = `≈${formattedCNY}`;
console.log(`[处理元素] 生成转换标签: ${conversionEl.textContent}`);
// 兼容多种插入位置，确保能插入
let insertPoint = element.querySelector('.product-price_wrap')
|| element.querySelector('.price-wrap')
|| element.querySelector('.price')
|| element; // 最后 fallback 到元素自身
insertPoint.appendChild(conversionEl);
console.log(`[处理元素] 标签已插入到:`, insertPoint);
element.classList.add('currency-processed');
processedElements.add(element);
} catch (e) {
console.error(`[处理元素] 插入失败:`, e);
}
}
function ConvertPageCurrencyValues() {
if (isProcessing) {
console.log(`[转换流程] 正在处理中，跳过`);
return;
}
isProcessing = true;
console.log(`=== 开始转换页面货币 ===`);
if (observer) observer.disconnect();
const validElements = FindPriceElements();
// 无新元素，只要有活跃货币，就更新悬浮窗（不隐藏）
if (validElements.length === 0) {
console.log(`[转换流程] 无新元素，但保留活跃货币`);
updateFloatPanel(currentActiveCurrency); // 用当前活跃货币更新，而非null
isProcessing = false;
if (observer) observer.observe(document.body, { childList: true, subtree: true });
return;
}
// （货币分组处理逻辑保持不变）
const currencyGroups = {};
validElements.forEach(el => {
const [_, currencyType, targetCurrency] = ExtractCurrencyInfo(el);
if (targetCurrency) {
if (!currencyGroups[currencyType]) {
currencyGroups[currencyType] = { currency: targetCurrency, elements: [] };
}
currencyGroups[currencyType].elements.push(el);
}
});
Object.values(currencyGroups).forEach(group => {
const { currency, elements } = group;
switch (currency.requestStatus) {
case 'idle':
elements.forEach(el => currency.addPendingElement(el));
currency.fetchExchangeRate();
break;
case 'pending':
elements.forEach(el => currency.addPendingElement(el));
updateFloatPanel(currency);
break;
case 'done':
elements.forEach(el => ProcessPriceElement(el, currency.Type));
updateFloatPanel(currency);
break;
}
});
if (observer) {
observer.observe(document.body, { childList: true, subtree: true });
}
isProcessing = false;
console.log(`=== 转换流程结束 ===`);
}
function ObserveDOMChanges() {
observer = new MutationObserver(mutations => {
let hasValidNewElement = false;
mutations.forEach(mutation => {
if (mutation.type !== 'childList') return;
mutation.addedNodes.forEach(node => {
if (node.nodeType !== Node.ELEMENT_NODE || node.id === 'currency-float-panel') return;
const [_, __, targetCurrency] = ExtractCurrencyInfo(node);
const hasChildValidEl = !!node.querySelector('.product-price:not(.currency-processed)')
&& ExtractCurrencyInfo(node.querySelector('.product-price:not(.currency-processed)'))[2];
if (targetCurrency || hasChildValidEl) {
hasValidNewElement = true;
if (targetCurrency) currentActiveCurrency = targetCurrency;
console.log(`[DOM监听] 检测到新增有效元素`);
}
});
});
if (hasValidNewElement && !isProcessing) {
console.log(`[DOM监听] 触发延迟转换`);
clearTimeout(window.currencyConversionTimeout);
window.currencyConversionTimeout = setTimeout(ConvertPageCurrencyValues, 500);
}
});
observer.observe(document.body, { childList: true, subtree: true });
console.log(`[DOM监听] 已开启`);
}
// 页面加载完成后初始化
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', init);
} else {
init();
}
})();