rapid-spreadjs 1.0.183 → 1.0.185

package/dist/index.cjs.js

@@ -1237,16 +1237,20 @@ const BusinessUtils = {
             });
             return itemExp;
         };
-        //将1~20这些数字替换为具体的设置条件
+        //将1~100这些数字替换为具体的设置条件
         const replaceNum = (itemExp, conJsonArr) => {
             const nums = [];
-            for (let iNum = 1; iNum <= 20; iNum++) {
+            for (let iNum = 1; iNum <= 100; iNum++) {
                 nums.push(iNum);
             }
             nums.forEach((num) => {
                 if (itemExp.indexOf(num) > -1 && num <= conJsonArr.length) {
                     //将条件公式【1 || (2 && 3)】中的数组替换为#1#的形式
-                    itemExp = itemExp.replaceAll(num, `#${num}#`);
+                    /**
+                     * 如下正则替换的原理为：将字符串中独立的数字66替换为Y
+                     *    '78ab5c66d5566e4566f66g'.replace(new RegExp(`(?<!\\d)${66}(?!\\d)`, 'g'), 'Y') → '78ab5cYd5566e4566fYg'
+                     */
+                    itemExp = itemExp.replace(new RegExp(`(?<!\\d)${num}(?!\\d)`, 'g'), `#${num}#`);
                 }
             });
             nums.forEach((num) => {
@@ -1299,6 +1303,8 @@ const BusinessUtils = {
                     //记录是否所有前置公式对应的条件都没有超差
                     let isAllNotCc = true;
                     for (let j = 0; j < qzGsJsonArr.length; j++) {
+                        // if (j == 11) debugger;
+                        // debugger;
                         const itemQzgs = qzGsJsonArr[j];
                         //当前公式中的前置条件
                         let curGsQz = itemQzgs.qzFor.replaceAll('jd(', '精度开始').replaceAll(')jd', '精度结束').replaceAll('abs', '[###]');
@@ -1345,7 +1351,7 @@ const BusinessUtils = {
                                         }
                                     }
                                 }
-                                break;
+                                // break;
                             }
                         }
                         catch (error) {
@@ -16780,6 +16786,79 @@ const FormulaUtils = {
                 // return calcVal(retArrVals[0], accuracy);
             },
         },
+        {
+            funName: 'YJROUNDKX',
+            funDesc: '计算科学计数修约',
+            funDefaultVal: null,
+            funParams: [
+                {
+                    name: '数值',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '修约位数',
+                    repeatable: false,
+                    optional: false,
+                },
+            ],
+            funCallback: (spread, sheet, retData) => {
+                let symbol = '/';
+                //如果传递的参数小于2个（第一个参数为修约的数值，第二个参数为修约位数），则返回符号
+                if (retData.allCellVals.length < 2) {
+                    return symbol;
+                }
+                //判断要修约的值和精度是否为数字，不是则返回符号
+                if (!FormulaUtils.commFun.isNumber(retData.allCellVals[0]) || !FormulaUtils.commFun.isNumber(retData.allCellVals[1])) {
+                    return symbol;
+                }
+                let retArrVals = FormulaUtils.commFun.convertToInt(retData.allCellVals);
+                //修约位数（正式以配置中为优先级获取，如业务系统中就要根据配置来判断）
+                let accuracy = Math.floor(retArrVals[1]);
+                //小于等于0时，返回原始数据
+                if (accuracy <= 0 || retArrVals[0] == 0) {
+                    return retArrVals[0];
+                }
+                /**
+                 * 将数字转换为统一的标准科学计数法表达字符串
+                 * @param {number} num - 需要转换的数字
+                 * @param {number} [digits] - 有效数字位数（默认自动推断）
+                 * @returns {string} 如 "1.34*10^-2"、"1.34"、"1.34*10³"
+                 */
+                const toScientificNotation = (num, digits) => {
+                    if (num === 0)
+                        return '0';
+                    if (!isFinite(num))
+                        return String(num);
+                    // 1. 确定有效数字位数：未指定时从原数推断
+                    if (digits === undefined) {
+                        const str = String(Math.abs(num));
+                        // 去除小数点和前导零，剩余即为有效数字
+                        digits = str.replace(/^0*\.?0*/, '').replace('.', '').length || 1;
+                    }
+                    // 2. 利用 toExponential 获取标准化系数和指数
+                    //    例如: (134).toExponential(2) => "1.34e+2"
+                    const expStr = num.toExponential(digits - 1);
+                    const [coefStr, expPart] = expStr.split('e');
+                    const exponent = parseInt(expPart, 10);
+                    // 3. 清理系数尾部多余的零（如 1.340 → 1.34）
+                    const coefficient = parseFloat(coefStr).toString();
+                    // 4. 根据指数值格式化输出
+                    if (exponent === 0) {
+                        // 指数为0：直接返回系数，如 "1.34"
+                        return coefficient;
+                    }
+                    // 上标映射表
+                    const superscripts = { '-': '⁻', '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴', '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹' };
+                    const expDisplay = String(exponent)
+                        .split('')
+                        .map((ch) => superscripts[ch] || ch)
+                        .join('');
+                    return `${coefficient}*10${expDisplay}`;
+                };
+                return toScientificNotation(retArrVals[0], accuracy);
+            },
+        },
         {
             funName: 'YJDZ',
             funDesc: '按照单元格点选顺序，优先提取最后一个有数据的单元格值',