rapid-spreadjs 1.0.59 → 1.0.61

package/dist/index.cjs.js

@@ -12856,6 +12856,7 @@ const FormulaUtils = {
         //自定义函数逻辑
         cusFun.prototype.evaluate = function () {
             // 获取该自定义公式被引用单元格的索引
+            console.log('所有参数：', arguments);
             /**
              * 说明：
              *     如果isContext=true，则arguments的第一个参数为上下文参数，后面的参数才是自定义参数真正传入的参数
@@ -19375,6 +19376,195 @@ const FormulaUtils = {
                 return d;
             },
         },
+        {
+            funName: 'YJDXPD',
+            funDesc: '单项判定',
+            funDefaultVal: null,
+            isAcceptArea: true,
+            funParams: [
+                {
+                    name: '判定范围，格式如：-2,2、-2~2或±2',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '判定值，如：1',
+                    repeatable: false,
+                    optional: false,
+                },
+            ],
+            funCallback: (spread, sheet, retData) => {
+                //如果传递的参数小于2个，则返回空字符串
+                if (retData.allCellVals.length < 2) {
+                    return '';
+                }
+                try {
+                    const rangeStr = retData.allCellVals[0], num = retData.allCellVals[1];
+                    // 参数基础校验
+                    if (typeof rangeStr !== 'string' || typeof num !== 'number' || isNaN(num)) {
+                        return '/';
+                    }
+                    // 去除字符串中的空格
+                    const cleanStr = rangeStr.replace(/\s/g, '');
+                    let min, max;
+                    // 处理三种格式
+                    if (cleanStr.includes(',')) {
+                        // 格式："-2,2"
+                        const parts = cleanStr.split(',');
+                        if (parts.length !== 2)
+                            return '/';
+                        min = parseFloat(parts[0]);
+                        max = parseFloat(parts[1]);
+                    }
+                    else if (cleanStr.includes('~')) {
+                        // 格式："-2~2"
+                        const parts = cleanStr.split('~');
+                        if (parts.length !== 2)
+                            return '/';
+                        min = parseFloat(parts[0]);
+                        max = parseFloat(parts[1]);
+                    }
+                    else if (cleanStr.includes('±')) {
+                        // 格式："±2"
+                        const valueStr = cleanStr.replace('±', '');
+                        const value = parseFloat(valueStr);
+                        if (isNaN(value))
+                            return '/';
+                        min = -value;
+                        max = value;
+                    }
+                    else {
+                        // 不是三种指定格式之一
+                        return '/';
+                    }
+                    // 检查解析结果是否有效
+                    if (isNaN(min) || isNaN(max)) {
+                        return '/';
+                    }
+                    // 判断数字是否在范围内
+                    if (num >= min && num <= max) {
+                        return '合格';
+                    }
+                    else {
+                        return '不合格';
+                    }
+                }
+                catch (error) {
+                    // 任何错误都返回"/"
+                    return '/';
+                }
+            },
+        },
+        {
+            funName: 'YJTEXTJOIN',
+            funDesc: '此函数将多个区域和/或字符串的文本组合起来，并包括你在要组合的各文本值之间指定的分隔符。',
+            funDefaultVal: null,
+            isAcceptArea: true,
+            funParams: [
+                {
+                    name: '需要用作判断的数字数组或字符串数组',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '返回值的数组',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '比较大小或比较相等的字符串，格式为：“>”、“<”、“>=”、“<=”、“=”',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '比较的值，类型为数字类型或字符串类型，如：3或“合格”',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '返回值的分隔符，默认为：,',
+                    repeatable: false,
+                    optional: false,
+                },
+            ],
+            funCallback: (spread, sheet, retData) => {
+                //如果传递的参数小于5个，则返回空字符串
+                if (retData.allCellValsEw.length < 5) {
+                    return '';
+                }
+                const array1 = retData.allCellValsEw[0], array2 = retData.allCellValsEw[1], operator = retData.allCellValsEw[2], value = retData.allCellValsEw[3], delimiter = retData.allCellValsEw[4];
+                try {
+                    // 参数基础校验
+                    if (!Array.isArray(array1) ||
+                        !Array.isArray(array2) ||
+                        array1.length !== array2.length ||
+                        typeof operator !== 'string' ||
+                        typeof delimiter !== 'string') {
+                        return '/';
+                    }
+                    // 验证operator参数的有效性
+                    const validOperators = ['>', '<', '>=', '<=', '='];
+                    if (!validOperators.includes(operator)) {
+                        return '/';
+                    }
+                    // 判断第一个数组的元素类型
+                    const isNumericArray = array1.length > 0 && (typeof array1[0] === 'number' || !isNaN(parseFloat(array1[0])));
+                    // 收集满足条件的索引
+                    const validIndices = [];
+                    for (let i = 0; i < array1.length; i++) {
+                        let conditionMet = false;
+                        if (isNumericArray) {
+                            // 数字数组：使用指定的比较运算符
+                            const num1 = parseFloat(array1[i]);
+                            const numValue = parseFloat(value);
+                            if (isNaN(num1) || isNaN(numValue)) {
+                                continue; // 跳过非数字元素
+                            }
+                            switch (operator) {
+                                case '>':
+                                    conditionMet = num1 > numValue;
+                                    break;
+                                case '<':
+                                    conditionMet = num1 < numValue;
+                                    break;
+                                case '>=':
+                                    conditionMet = num1 >= numValue;
+                                    break;
+                                case '<=':
+                                    conditionMet = num1 <= numValue;
+                                    break;
+                                case '=':
+                                    conditionMet = num1 === numValue;
+                                    break;
+                            }
+                        }
+                        else {
+                            // 字符串数组：只进行相等比较
+                            conditionMet = String(array1[i]) === String(value);
+                        }
+                        if (conditionMet) {
+                            validIndices.push(i);
+                        }
+                    }
+                    // 从第二个数组中获取对应索引的值
+                    const resultValues = validIndices
+                        .map((index) => {
+                        // 确保索引在第二个数组范围内
+                        if (index >= 0 && index < array2.length) {
+                            return String(array2[index]);
+                        }
+                        return '';
+                    })
+                        .filter((val) => val !== ''); // 过滤空值
+                    // 使用指定的分隔符连接结果[2,3,5](@ref)
+                    return resultValues.join(delimiter);
+                }
+                catch (error) {
+                    // 任何错误都返回"/"
+                    return '/';
+                }
+            },
+        },
         {
             funName: 'YJTREND',
             funDesc: '返回线性回归拟合线的一组纵坐标值(y值)',