rapid-spreadjs 1.0.66 → 1.0.68

package/dist/index.esm.js

@@ -19449,7 +19449,7 @@ const FormulaUtils = {
                     optional: false,
                 },
                 {
-                    name: '比较大小或比较相等的字符串，格式为：“>”、“<”、“>=”、“<=”、“=”',
+                    name: '比较大小或比较相等的字符串，格式为：“>”、“<”、“>=”、“<=”、“=”、“±”',
                     repeatable: false,
                     optional: false,
                 },
@@ -19463,68 +19463,141 @@ const FormulaUtils = {
                     repeatable: false,
                     optional: false,
                 },
+                {
+                    name: '是否返回相反的结果（传数字的1或0，0：满足条件的结果、1：相反的结果），默认为：0',
+                    repeatable: false,
+                    optional: false,
+                },
             ],
             funCallback: (spread, sheet, retData) => {
-                //如果传递的参数小于5个，则返回空字符串
-                if (retData.allCellValsEw.length < 5) {
+                //如果传递的参数小于6个，则返回空字符串
+                if (retData.allCellValsEw.length < 6) {
                     return '';
                 }
-                const array1 = retData.allCellValsEw[0], array2 = retData.allCellValsEw[1], operator = retData.allCellValsEw[2], value = retData.allCellValsEw[3], delimiter = retData.allCellValsEw[4];
+                let array1 = retData.allCellValsEw[0], array2 = retData.allCellValsEw[1], operator = retData.allCellValsEw[2], value = retData.allCellValsEw[3], delimiter = retData.allCellValsEw[4], isOpposite = retData.allCellValsEw[5];
                 try {
+                    // 处理array1和array2的默认值
+                    if (array1 == null || array1 == undefined || (typeof array1 == 'string' && array1.trim().length == 0)) {
+                        array1 = [];
+                    }
+                    if (array2 == null || array2 == undefined || (typeof array2 == 'string' && array2.trim().length == 0)) {
+                        array2 = [];
+                    }
+                    if (typeof array1 == 'string' && array1.trim().length > 0) {
+                        array1 = [array1];
+                    }
+                    if (typeof array2 == 'string' && array2.trim().length > 0) {
+                        array2 = [array2];
+                    }
+                    // 如果operator、value、delimiter、isOpposite为数组，则设置其取第一个值
+                    if (Array.isArray(operator) && operator.length > 0) {
+                        operator = operator[0];
+                    }
+                    if (Array.isArray(value) && value.length > 0) {
+                        value = value[0];
+                    }
+                    if (Array.isArray(delimiter) && delimiter.length > 0) {
+                        delimiter = delimiter[0];
+                    }
+                    if (Array.isArray(isOpposite) && isOpposite.length > 0) {
+                        isOpposite = isOpposite[0];
+                    }
+                    // 设置isOpposite的默认值
+                    if (isOpposite == '1' || isOpposite == '0') {
+                        isOpposite = parseInt(isOpposite);
+                    }
+                    if (isOpposite != 0 && isOpposite != 1) {
+                        isOpposite = 0;
+                    }
+                    // TODO：暂定此情况
+                    // 第一个参数是否为单值（array1为一个值的时候，此时array2的所有元素可能需要参与计算，满足要求的就返回array2中的值）
+                    const isSingleValue1 = array2.length > array1.length && array1.length == 1;
                     // 参数基础校验
                     if (!Array.isArray(array1) ||
                         !Array.isArray(array2) ||
-                        array1.length !== array2.length ||
+                        // array1.length !== array2.length ||
                         typeof operator !== 'string' ||
                         typeof delimiter !== 'string') {
                         return '/';
                     }
                     // 验证operator参数的有效性
-                    const validOperators = ['>', '<', '>=', '<=', '='];
+                    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++) {
+                    // 收集满足条件的索引和不满足条件的索引
+                    const validIndices = [], oppositeIndices = [];
+                    for (let i = 0; i < array2.length; i++) {
                         let conditionMet = false;
                         if (isNumericArray) {
-                            // 数字数组：使用指定的比较运算符
-                            const num1 = parseFloat(array1[i]);
+                            // 第一个参数为单值的时候，取第一个值
+                            const num1 = isSingleValue1 ? parseFloat(array1[0]) : parseFloat(array1[i]);
+                            const num2 = parseFloat(array2[i]);
                             const numValue = parseFloat(value);
-                            if (isNaN(num1) || isNaN(numValue)) {
+                            if (isNaN(num1) || (isNaN(numValue) && !isSingleValue1)) {
                                 continue; // 跳过非数字元素
                             }
                             switch (operator) {
                                 case '>':
-                                    conditionMet = num1 > numValue;
+                                    if (isSingleValue1) {
+                                        conditionMet = num1 > num2;
+                                    }
+                                    else {
+                                        conditionMet = num1 > numValue;
+                                    }
                                     break;
                                 case '<':
-                                    conditionMet = num1 < numValue;
+                                    if (isSingleValue1) {
+                                        conditionMet = num1 < num2;
+                                    }
+                                    else {
+                                        conditionMet = num1 < numValue;
+                                    }
                                     break;
                                 case '>=':
-                                    conditionMet = num1 >= numValue;
+                                    if (isSingleValue1) {
+                                        conditionMet = num1 >= num2;
+                                    }
+                                    else {
+                                        conditionMet = num1 >= numValue;
+                                    }
                                     break;
                                 case '<=':
-                                    conditionMet = num1 <= numValue;
+                                    if (isSingleValue1) {
+                                        conditionMet = num1 <= num2;
+                                    }
+                                    else {
+                                        conditionMet = num1 <= numValue;
+                                    }
                                     break;
                                 case '=':
-                                    conditionMet = num1 === numValue;
+                                    if (isSingleValue1) {
+                                        conditionMet = num1 === num2;
+                                    }
+                                    else {
+                                        conditionMet = num1 === numValue;
+                                    }
+                                    break;
+                                case '±':
+                                    conditionMet = num2 >= num1 - numValue && num2 <= num1 + numValue;
                                     break;
                             }
                         }
                         else {
-                            // 字符串数组：只进行相等比较
+                            // 字符串数组：只进行相等比较（忽略operator，包括"±"）[6](@ref)
                             conditionMet = String(array1[i]) === String(value);
                         }
                         if (conditionMet) {
                             validIndices.push(i);
                         }
+                        else {
+                            oppositeIndices.push(i);
+                        }
                     }
                     // 从第二个数组中获取对应索引的值
-                    const resultValues = validIndices
+                    const resultValues = (isOpposite == 0 ? validIndices : oppositeIndices)
                         .map((index) => {
                         // 确保索引在第二个数组范围内
                         if (index >= 0 && index < array2.length) {