请选择 进入手机版 | 继续访问电脑版
 找回密码
 立即注册

QQ登录

只需一步,快速开始

本帖最后由 Richard.Ma 于 2024-7-5 16:43 编辑

此前,我们写过一个教程“利用自定义公式实现“四舍六入五成双”
https://gcdn.grapecity.com.cn/showtopic-141668-1-5.html
通过上述方式,可以设置公式来得到一个符合“银行家算法”的公式结果作为单元格值。

但是在一些场景中,“四舍六入五成双(银行家算法)”的修约结果仅需要作为最终的显示内容。用户仍需要单元格的值保持修约前的原始值来参与后续的计算


基于上述场景,就有了这篇教程,会介绍通过自定义单元格,在单元格的paint方法中,
根据单元格的实际值,和要保留的小数位数(来自单元格格式字符串)
进行修约后显示,其中的“四舍六入五成双”处理逻辑和上篇教程相同


演示效果如下
左右两列的单元格值相同,左侧为默认单元格类型。右侧设置了BankersRoundCellType来实现以修约结果显示
可以看到编辑值未受到影响
image.png82993163.png




关键代码

定义自定义单元格类型,继承Text单元格类型,仅重写paint方法,不影响编辑
  1. function BankersRoundCellType() {
  2. }
  3. BankersRoundCellType.prototype = new spreadNS.CellTypes.Text();
  4. BankersRoundCellType.prototype.paint = function (ctx, value, x, y, w, h, style, options) {
  5.     if (value) {
  6.         //在这里对单元格值进行处理,使用value和formatter中获取的小数位数,对数字继续修约,其他类型保持原值
  7.         let places = this.getDecimalPlaces(style.formatter);//小数点位数
  8.         let resultvalue = this.bankersRound(value,places);
  9.         

  10.         spreadNS.CellTypes.Text.prototype.paint.apply(this, [ctx, resultvalue, x, y, w, h, style, options]);
  11.     }
  12. };
复制代码


上述代码中用到的和银行家算法相关的其他方法也添加到自定义单元格原型中

  1. BankersRoundCellType.prototype.bankersRound = function (value, places) {
  2.     if (!isNaN(parseInt(value)) && !isNaN(parseInt(places))) {
  3.         value = this.numGeneral(value);
  4.         if (!this.isNumber(value)) {
  5.             return value;
  6.         }
  7.         var d = places || 0;
  8.         var m = Math.pow(10, d);
  9.         var n = +(d ? value * m : value).toFixed(8); // Avoid rounding errors
  10.         var i = Math.floor(n),
  11.             f = n - i;
  12.         var e = 1e-8; // Allow for rounding errors in f
  13.         var r = f > 0.5 - e && f < 0.5 + e ? (i % 2 == 0 ? i : i + 1) : Math.round(n);
  14.         var result = d ? r / m : r;

  15.         if (places > 0) {
  16.             var s_x = result.toString();
  17.             var pos_decimal = s_x.indexOf(".");
  18.             if (pos_decimal < 0) {
  19.                 pos_decimal = s_x.length;
  20.                 s_x += ".";
  21.             }
  22.             while (s_x.length <= pos_decimal + places) {
  23.                 s_x += "0";
  24.             }
  25.             return Number(s_x);
  26.         } else {
  27.             return Number(result);
  28.         }
  29.     } else {
  30.         return value;
  31.     }
  32. }

  33. BankersRoundCellType.prototype.numGeneral = function (val, mand, type) {

  34.     var matCheck = function (v) {
  35.         return String(v).match(
  36.             /^([\D\-(?!\d)\.(?!\d)]*?)((\-?\d*\.?\d+)((e|E)(\+|\-)?(\d+))?)(.*)$/
  37.         );
  38.     };
  39.     var reVal = matCheck(val);
  40.     if (reVal) {
  41.         if (typeof mand == "string" && !type) type = mand;
  42.         var reMatch = function (matchs) {
  43.             var num = matchs[2],
  44.                 res = "",
  45.                 last = matchs[8] || "",
  46.                 isF = Number.isFinite || isFinite;
  47.             if (type === "number") {
  48.                 return [Number(num), last];
  49.             } else if (matchs[4]) {
  50.                 var p1 = "",
  51.                     p2 = "",
  52.                     pm = 1;
  53.                 if (num.indexOf("-") === 0) (pm = 0), (num = num.substr(1));
  54.                 num = num.replace(/^0+/, "").replace(/^\./, "0.");
  55.                 var dot = num.indexOf("."),
  56.                     power = Number(matchs[7]) || 0,
  57.                     ONnum = num
  58.                         .replace(/(e|E).+$/, "")
  59.                         .replace(/(\.\d+?)0+$/, "$1")
  60.                         .replace(/\.0+$|\./g, "");
  61.                 if (dot != -1) {
  62.                     (p1 = ONnum.substring(0, dot)),
  63.                         (p2 = ONnum.substring(dot, ONnum.length));
  64.                 }
  65.                 if (matchs[6] == "-") {
  66.                     if (dot == -1) {
  67.                         ONnum = ONnum.replace(/^0+/, "");
  68.                         if (power < ONnum.length) {
  69.                             res =
  70.                                 ONnum.substr(0, ONnum.length - power) +
  71.                                 "." +
  72.                                 ONnum.substr(-power);
  73.                         } else {
  74.                             for (var i = 0, le = power - ONnum.length; i < le; i++)
  75.                                 ONnum = "0" + ONnum;
  76.                             res = "0." + ONnum;
  77.                         }
  78.                     } else {
  79.                         if (!/[^0]/.test(p1)) {
  80.                             p1 = "0.";
  81.                             for (var i = 0; i < power; i++) p1 += "0";
  82.                         } else if (power < p1.length) {
  83.                             p1 = p1.substr(0, p1.length - power) + "." + p1.substr(-power);
  84.                         } else {
  85.                             for (var i = 0, le = power - p1.length; i < le; i++)
  86.                                 p1 = "0" + p1;
  87.                             p1 = "0." + p1;
  88.                         }
  89.                         res = p1 + p2;
  90.                     }
  91.                 } else {
  92.                     if (dot == -1) {
  93.                         res = ONnum.replace(/^0+/, "");
  94.                         for (var i = 0; i < power; i++) res += "0";
  95.                     } else {
  96.                         if (power < p2.length) {
  97.                             p2 = p2.substr(0, power) + "." + p2.substr(power);
  98.                         } else {
  99.                             for (var i = 0, le = power - p2.length; i < le; i++) p2 += "0";
  100.                         }
  101.                         res = p1 + p2;
  102.                     }
  103.                 }
  104.                 res = res
  105.                     .replace(/^0+(?!\.)/, "")
  106.                     .replace(/(\.\d+?)0+$/, "$1")
  107.                     .replace(/\.0+$|\.$/, "");
  108.                 if (isF(Number(res)) && !String(Number(res)).match(/e|E/)) {
  109.                     res = pm < 1 ? -Number(res) : Number(res);
  110.                 } else {
  111.                     res = pm < 1 ? "-" + res : res;
  112.                 }
  113.             } else {
  114.                 res =
  115.                     matchs[3] && isF(Number(matchs[3])) && !matCheck(Number(matchs[3]))[4]
  116.                         ? Number(matchs[3])
  117.                         : num;
  118.             }
  119.             return [type === "string" ? String(res) : res, last];
  120.         };
  121.         if (reVal[8] && mand == true) {
  122.             var has = true,
  123.                 matARR = [reMatch(reVal)];
  124.             var numARR = [matARR[0][0]];
  125.             while (has == true) {
  126.                 var lastMat = matCheck(matARR[matARR.length - 1][1]);
  127.                 if (lastMat) {
  128.                     var last = reMatch(lastMat);
  129.                     matARR.push(last), numARR.push(last[0]);
  130.                 } else has = false;
  131.             }
  132.             return numARR.length > 1 ? numARR : matARR[0][0];
  133.         } else {
  134.             return reMatch(reVal)[0];
  135.         }
  136.     } else {
  137.         return val;
  138.     }
  139. }

  140. BankersRoundCellType.prototype.isNumber = function (val) {
  141.    
  142.     var regPos = /^\d+(\.\d+)?$/; //非负浮点数
  143.     var regNeg =
  144.         /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/; //负浮点数
  145.     if (regPos.test(val) || regNeg.test(val)) {
  146.         return true;
  147.     } else {
  148.         return false;
  149.     }
  150. }

  151. BankersRoundCellType.prototype.getDecimalPlaces = function (format) {
  152.     if (format === undefined) {
  153.         return 0;
  154.     }
  155.     // 找到小数点的位置
  156.     const decimalPointIndex = format.indexOf('.');

  157.     // 如果没有小数点,返回0
  158.     if (decimalPointIndex === -1) {
  159.         return 0;
  160.     }

  161.     // 小数点后的字符数即为保留的小数位数
  162.     return format.length - decimalPointIndex - 1;
  163. }
复制代码



具体的demo,请打开下面的在线示例
https://jscodemine.grapecity.com/sample/CAm5KT0HUUqBojok77DSZA/



image.png721471862.png



或者下载在本地运行
features_cells_cell-types_custom_JavaScript_cc95ab_2024-07-05.zip (3.75 KB, 下载次数: 0)

0 个回复

您需要登录后才可以回帖 登录 | 立即注册
返回顶部