☰

淘宝、京东、天猫自动按每斤价格排序 TAOBAO/JD/TMALL / Automatic sort by 500g price.

注：淘宝的价格和商品标题上写的重量通常对不上，点进商品页面，选择分类即可了解商品小分类的价格、京东暂无此问题, 标题出现2个以上重量单位的按最后一个算。( bug反馈联系： snomiao@gmail.com 或 qq 997596439 )

目前为 2022-01-13 提交的版本。查看 最新版本。

  1. // ==UserScript==
  2. // @name         淘宝、京东、天猫自动按每斤价格排序 TAOBAO/JD/TMALL / Automatic sort by 500g price.
  3. // @namespace    snomiao@gmail.com
  4. // @version      1.1.9
  5. // @description  注：淘宝的价格和商品标题上写的重量通常对不上，点进商品页面，选择分类即可了解商品小分类的价格、京东暂无此问题, 标题出现2个以上重量单位的按最后一个算。( bug反馈联系： snomiao@gmail.com 或 qq 997596439 )
  6. // @author       snomiao@gmail.com
  7. // @match        http*://cart.jd.com/cart*
  8. // @match        http*://order.jd.com/center/alwaysbuy.action*
  9. // @match        http*://*.jd.com/*.html
  10. // @match        http*://*.jd.com/*.html?*
  11. // @match        http*://search.jd.com/*
  12. // @match        http*://*.tmall.com/*.htm*
  13. // @match        http*://*.taobao.com/search*
  14. // @match        http*://item.taobao.com/item.htm*
  15. // @match        http*://cart.taobao.com/cart.htm*
  16. // @match        http*://www.1688.com/*
  17. // @match        http*://s.1688.com/selloffer/offer_search.htm*
  18. // @match        http*://search.suning.com/*
  19. // @match        http*://*.amazon.*/*
  20. // @grant        none
  21. // ==/UserScript==
  22.  
  23. //
  24. // (20210221)更新：性能优化、数据单位识别优化、更新天猫超市、amazon、suning、加入中文数字识别
  25. // (20200404)更新：增加天猫超市支持、优化刷新逻辑
  26. //
  27. // (function () {
  28. //     'use strict';
  29. // 获取质量参数
  30. // 重量、容积单位（按水的重量算）
  31. const 重量单位比例表 = {
  32.     ton: 1e6,
  33.     kg: 1e3,
  34.     g: 1,
  35.     克: 1,
  36.     mg: 1e-3,
  37.     ug: 1e-6,
  38.     l: 1e3,
  39.     ml: 1,
  40.     千克: 1e3,
  41.     磅: 453.59237,
  42.     lb: 453.59237,
  43.     吨: 1e6,
  44.     公斤: 1e3,
  45.     斤: 500,
  46.     两: 50,
  47. };
  48. // 数据单位（采用硬盘工业单位，一般商品上标的都是这种）
  49. const 数据单位比例表 = {
  50.     t: 1e3,
  51.     g: 1,
  52.     //   m: 1e-3, //和米冲突
  53.     k: 1e-6,
  54.     pb: 1e6,
  55.     tb: 1e3,
  56.     gb: 1,
  57.     mb: 1e-3,
  58.     kb: 1e-6,
  59. };
  60. const 单位比例表 = {
  61.     ...重量单位比例表,
  62.     ...数据单位比例表,
  63. };
  64. // 匹配： 前缀乘数？ 基数量 基数单位 后缀乘数？
  65. const 质量正则 = RegExp(
  66.     [
  67.         /(?:(\d+)\s?\*)?/,
  68.         /(\d+\.\d+|\d+)/,
  69.         RegExp(`(${Object.keys(单位比例表).join('|')})`),
  70.         /(?:\s?[x×*](\d+))?/,
  71.     ]
  72.         .map((e) => e.source)
  73.         .join(''),
  74.     'i'
  75. );
  76. // 数学与文本处理方法
  77. const 分组计数 = (列, 按 = (e) => JSON.stringify(e)) =>
  78.     列.reduce((表, 数) => ((表[数] = (表[数] || 0) + 1), 表), {});
  79. const 众数 = (列) =>
  80.     Object.entries(分组计数(列)).sort(([, v1], [, v2]) => v2 - v1)[0][0];
  81. const 中文数字解析 = (大写数字) =>
  82.     大写数字.split('').reduce(
  83.         (数, 字) =>
  84.             // (e=> e !==-1 && (数 ?? 0) + e)('012345789'.indexOf(字) ) ||
  85.             ((e) => e !== -1 && (数 ?? 0) + e)(
  86.                 '零一二三四五六七八九'.indexOf(字)
  87.             ) ||
  88.             ((e) => e !== -1 && (数 ?? 0) + e)(
  89.                 '零壹贰叁肆伍陆柒捌玖'.indexOf(字)
  90.             ) ||
  91.             ((e) => e !== -1 && (数 ?? 0) + e)(
  92.                 '洞幺两三四五六拐怕勾'.indexOf(字)
  93.             ) ||
  94.             ((e) => e !== -1 && (数 ?? 1) * 10 ** e)(
  95.                 '个十百千万一兆一亿'.indexOf(字)
  96.             ) ||
  97.             ((e) => e !== -1 && (数 ?? 1) * 10 ** e)('个拾佰仟'.indexOf(字)) ||
  98.             NaN,
  99.         null
  100.     );
  101. const 中文数字替换 = (串) =>
  102.     串.replace(
  103.         /[幺两三四五六拐怕勾洞零一二三四五六七八九零壹贰叁肆伍陆柒捌玖个十][幺两三四五六拐怕勾洞零一二三四五六七八九零壹贰叁肆伍陆柒捌玖个十百千万一兆一亿个拾佰仟]*/g,
  104.         中文数字解析
  105.     );
  106. 中文数字替换(
  107.     `四万万 四亿 四亿亿 二万二千 二百二 三十三 四百 六十四 五百亿 两个亿 十一`
  108. );
  109. const 范围映射 = (x, [a, b], [c, d]) => ((x - a) / (b - a)) * (d - c) + c;
  110. // 调试
  111. const 查看 = (e) => (console.log(e), e);
  112. // 流程控制
  113. function 节流(间隔, 函数, 提示函数 = () => null, 上次执行 = 0) {
  114.     return async (...参数) =>
  115.         +new Date() - 上次执行 > 间隔
  116.             ? ((上次执行 = +new Date()), await 函数(...参数))
  117.             : await 提示函数(...参数);
  118. }
  119. function 防抖(间隔, 函数, 提示函数 = () => null, timerId = null) {
  120.     return (...参数) =>
  121.         new Promise(
  122.             (resolve, reject) => (
  123.                 timerId && (clearTimeout(timerId), resolve(提示函数(...参数))),
  124.                 (timerId = setTimeout(() => resolve(函数(...参数)), 间隔))
  125.             )
  126.         );
  127. }
  128. const 节流防抖 = (间隔, 函数, 提示函数 = () => null) =>
  129.     节流(间隔, 函数, 防抖(间隔, 函数, 提示函数));
  130. // 量纲计算
  131. const 质量千克自标题解析 = (标题) => {
  132.     const 质量表述列 =
  133.         (中文数字替换(标题) + 标题).match(RegExp(质量正则.source, 'ig')) || [];
  134.     const 质量列 = 质量表述列.map((串) => {
  135.         const [_, 前乘数串, 质量串, 单位串, 后乘数串] = 串.match(质量正则);
  136.         const [前乘数, 后乘数] = [前乘数串, 后乘数串].map(
  137.             (e) => parseFloat(e) || 1
  138.         );
  139.         const 质量 = parseFloat(质量串) || 0;
  140.         const 单位乘数 = 单位比例表[单位串.toLowerCase()];
  141.         return (前乘数 * 质量 * 单位乘数 * 后乘数) / 1e3; //kg
  142.     });
  143.     return 质量列.length ? parseFloat(众数(质量列)) : NaN;
  144. };
  145. const 每千克价格按每斤解释 = (每千克价格) =>
  146.     `${(每千克价格 / 2).toFixed(2)}¥/500g`;
  147. // 元素操作
  148. const 页面特定商品列获取 = ({ 选项目, 选标题, 选价格 }) =>
  149.     [...document.querySelectorAll(选项目)]
  150.         .map((元素) => {
  151.             let [标题元素, 价格元素] = [选标题, 选价格].map((选) =>
  152.                 选?.startsWith('DOC>')
  153.                     ? document.querySelector(选?.slice('DOC>'.length))
  154.                     : 元素?.querySelector(选)
  155.             );
  156.             if (!标题元素 || !价格元素) return null;
  157.             const 标题 = 标题元素.innerText.trim();
  158.             let 价格 =
  159.                 parseFloat(价格元素.innerText.trim().replace(/￥|¥/g, '')) ||
  160.                 NaN; //无报价
  161.             let 千克质量 = 质量千克自标题解析(标题);
  162.             const 每千克价格 = 价格 / (千克质量 || 0);
  163.             return {
  164.                 标题,
  165.                 价格,
  166.                 千克质量,
  167.                 每千克价格,
  168.                 标题元素,
  169.                 价格元素,
  170.                 元素,
  171.             };
  172.         })
  173.         .filter((e) => e);
  174. const 抽取并在末尾插入 = (元素) =>
  175.     元素.parentNode.appendChild(元素.parentNode.removeChild(元素));
  176. const 新元素 = (innerHTML, attributes = {}) =>
  177.     Object.assign(
  178.         Object.assign(document.createElement('div'), { innerHTML }).children[0],
  179.         attributes
  180.     );
  181. // 商品计算
  182. const 商品列每斤价格排序显示 = (新增商品列) => {
  183.     console.log(`[pricesof500g] 正在处理${新增商品列.length}个商品价格。`);
  184.     const 现存商品元素列 = [...document.querySelectorAll('span.priceof500g')];
  185.     const 现存商品列 = 现存商品元素列.map((价格标签) => 价格标签.商品信息);
  186.     const 每千克价格对比 = (a, b) => a.每千克价格 - b.每千克价格;
  187.     const 有序商品列 = [...现存商品列, ...新增商品列].sort(每千克价格对比);
  188.     const 有效价格列 = 有序商品列
  189.         .map((e) => e.每千克价格)
  190.         .filter((e) => !isNaN(e));
  191.     const 最低每千克价格 = Math.min(...有效价格列);
  192.     const 最高每千克价格 = Math.max(...有效价格列);
  193.     console.debug('当页商品价格列', 有序商品列, 最低每千克价格, 最高每千克价格);
  194.     const 商品信息解释生成 = (商品信息) => {
  195.         const { 标题, 千克质量, 价格, 每千克价格, 标题元素 } = 商品信息;
  196.         let 价率 = 范围映射(
  197.             每千克价格,
  198.             [最低每千克价格, 最高每千克价格],
  199.             [1, 0]
  200.         );
  201.         // 从最低价到最高价由红到绿渐变
  202.         const 颜色 =
  203.             (价率 && `rgba(${价率 * 255},${255 - 价率 * 255},0.1,1)`) ||
  204.             'black';
  205.         const 描述 = `${标题}\n\n${价格}¥/${千克质量}kg = ${每千克价格按每斤解释(
  206.             每千克价格
  207.         )}\n\n © 2016 - 2021 雪星实验室 \n  ( bug反馈联系： snomiao@gmail.com 或 qq 997596439 )`;
  208.         const 价格标签 = 新元素(`
  209. <span class="priceof500g" style="background: ${颜色}; color: white" title="${描述}">
  210.   ${每千克价格按每斤解释(每千克价格)}
  211. </span>`);
  212.  
  213.         价格标签.商品信息 = 商品信息;
  214.         // 标记商品已处理
  215.         商品信息.元素?.classList.add('pricesof500g');
  216.         // 标签换新或显示
  217.         标题元素.价格标签 && 标题元素.parentNode.removeChild(标题元素.价格标签);
  218.         if (!价格 || !千克质量) return;
  219.         标题元素.价格标签 = 标题元素.parentNode.insertBefore(
  220.             价格标签,
  221.             标题元素
  222.         );
  223.     };
  224.     有序商品列.forEach(({ 元素 }) => 抽取并在末尾插入(元素));
  225.     有序商品列.forEach(商品信息解释生成);
  226. };
  227. const 商品选择列 = `
  228. | taobao.com | .item                       | .title a              | .price                             | 商品页面
  229. | taobao.com | .tb-property                | .tb-main-title        | .tb-property-cont                  | 商品搜索结果页面
  230. | taobao.com | .item-holder                | .item-basic-info a    | .price-now                         | 购物车
  231. | taobao.com | .bundle                     | .item-basic-info a    | .price-now                         | 购物车商品页面标题
  232. | taobao.com | .item-holder                | .item-props           | .price-now                         | 购物车商品分类标签 https://cart.taobao.com/cart.htm
  233. | taobao.com | #J_OrderList>div            | .item-basic-info a    | .price-now                         | 购物车
  234. | taobao.com | .J_TSaleProp>li.tb-selected | a                     | DOC>#J_PromoPriceNum,.tm-price     | 小的商品描述标签，
  235. | tmall.com  | .product                    | .productTitle a       | .productPrice                      |
  236. | tmall.com  | .product                    | .product-title a      | .ui-price                          |
  237. | tmall.com  | .j_ItemInfo                 | .title                | .price                             |
  238. | tmall.com  | .one-grid-price             | .floor-item-title     | .floor-price                       |
  239. | tmall.com  | .wonderful-item             | .item-desc            | .item-price                        |
  240. | tmall.com  | .J_TSaleProp>li.tb-selected | a                     | DOC>.tm-promo-price                | 小的商品描述标签
  241. | tmall.com  | .tb-property                | h1                    | .tm-promo-price                    | 详情页标题
  242. | tmall.com  | .tm-detail-meta             | .tb-detail-hd h1      | .tm-promo-price                    | 详情页标题
  243. | jd.com     | .itemInfo-wrap              | .sku-name             | .p-price                           | 当前浏览商品
  244. | jd.com     | ul>li.more2_item            | .more2_info_name      | .more2_info_price                  | 首页推荐
  245. | jd.com     | .freqt-item                 | .p-name a             | .p-price                           | 常购商品
  246. | jd.com     | .gl-item                    | .p-name em            | .p-price                           |
  247. | jd.com     | .track-con>ul>li            | a>div                 | a>p                                | 看了又看
  248. | jd.com     | ul.plist>li                 | .p-name               | .p-price                           | 店铺新品、店铺热销、店长推荐等
  249. | jd.com     | ul>li.item                  | .p-name               | .p-price                           | 本店好评
  250. | jd.com     | .goods-list>ul>li           | .p-name a             | .p-price                           | JD购物车
  251. | jd.com     | .item-item,.item-full       | .p-name a             | .p-price                           | JD购物车
  252. | jd.com     | .smart-items>ul>li          | .item-name a          | .item-price                        | JD购物车
  253. | 1688.com   | .grid.rec-offer             | .offer_titles         | .price-num                         | 首页
  254. | 1688.com   | .sm-offer-item              | .sm-offer-title       | .sm-offer-priceNum                 | 商品搜索页面
  255. | 1688.com   | .card-container             | .title                | div.price                          | 商品搜索页面
  256. | amazon.cn  | .s-result-item              | h2                    | .a-price                           | 商品搜索页面
  257. | suning.com | li.item-wrap                | .title-selling-point  | .price-box                         | 商品搜索页面
  258. `
  259.     .replace(/\/\/.*/gm, '')
  260.     .split(/\r?\n/g)
  261.     .map((e) =>
  262.         e
  263.             .trim()
  264.             .split('|')
  265.             .slice(1)
  266.             .map((e) => e.trim())
  267.     )
  268.     .filter((e) => e && e[1])
  269.     .map(([域名, 选项目, 选标题, 选价格]) => ({
  270.         域名,
  271.         选项目,
  272.         选标题,
  273.         选价格,
  274.     }));
  275. const 页面商品列获取 = () =>
  276.     商品选择列
  277.         .filter(({ 域名 }) => location.origin.match(域名))
  278.         .flatMap(页面特定商品列获取);
  279. const 页面商品列商品列每斤价格排序显示 = () =>
  280.     !document.hidden && 商品列每斤价格排序显示(页面商品列获取());
  281. // 标签探索
  282. function 价格标签探索() {
  283.     // var 商品标签列 = [...document.querySelectorAll('.J_TSaleProp>li')];
  284.     // var 价格解释含于 = (e) => !e.querySelector('span.priceof500g');
  285.     // var 价格解释含于 = (e) => !e.querySelector('span.priceof500g');
  286.     // var 未解释商品标签列 = 商品标签列.filter(价格解释含于);
  287.     var 未解释商品标签列 = [
  288.         ...document.querySelectorAll('.J_TSaleProp>li:not(.pricesof500g)'),
  289.     ];
  290.     if (!未解释商品标签列.length) return;
  291.     console.log(
  292.         '[pricesof500g] 发现' + 未解释商品标签列.length + '个未解释商品标签列'
  293.     );
  294.     var 剩余未解释商品标签点击 = () => {
  295.         var 未解释商品标签 = 未解释商品标签列?.pop();
  296.         未解释商品标签?.querySelector('a')?.click();
  297.         未解释商品标签 && setTimeout(主动刷新函数, 1);
  298.         未解释商品标签 && setTimeout(剩余未解释商品标签点击, 100);
  299.     };
  300.     剩余未解释商品标签点击();
  301. }
  302. // 主函数
  303. function 刷新() {
  304.     页面商品列商品列每斤价格排序显示();
  305. }
  306. globalThis.价格标签探索 = 价格标签探索;
  307. const 防抖刷新 = 节流防抖(10e3 /* 3s */, 刷新);
  308. const 主动刷新函数 = 节流防抖(200, 刷新);
  309. const 延时刷新 = () => setTimeout(防抖刷新, 1);
  310. const 延时主动刷新 = () => setTimeout(主动刷新函数, 1);
  311. // オブザーバインスタンスを作成
  312. const 监视目标 = document.documentElement || document.body;
  313. const 监视配置 = {
  314.     attributes: false,
  315.     childList: true,
  316.     characterData: false,
  317. };
  318. function 页面变动处理(mutations) {
  319.     if (!mutations.some((record) => record.addedNodes.length)) return;
  320.     页面变动监视器.disconnect();
  321.     防抖刷新();
  322.     监视目标 && 页面变动监视器.observe(监视目标, 监视配置);
  323. }
  324. const 页面变动监视器 = new MutationObserver(页面变动处理);
  325. function 加载() {
  326.     页面变动监视器.observe(监视目标, 监视配置);
  327.     window.addEventListener('load', 防抖刷新, false);
  328.     document.addEventListener('keyup', 延时刷新, false);
  329.     document.addEventListener('mouseup', 延时主动刷新, false);
  330.     document.addEventListener('visibilitychange', 延时刷新, false);
  331.     防抖刷新();
  332. }
  333. function unload() {
  334.     window.removeEventListener('load', 防抖刷新, false);
  335.     document.removeEventListener('keyup', 延时刷新, false);
  336.     document.removeEventListener('mouseup', 延时主动刷新, false);
  337.     document.removeEventListener('visibilitychange', 延时刷新, false);
  338.     页面变动监视器.disconnect();
  339. }
  340. 加载();
  341. // 全局卸载函数（自动卸载上一个实例）
  342. globalThis?.pricesof500g_unload?.();
  343. globalThis.pricesof500g_unload = unload;
  344. // return unload;
  345. // })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址