多条件判断修改

src/views/formula/component/funComponent/multiIfElseTools.js

@@ -8,6 +8,8 @@ export function convertArrayToExpression(arr) {
   
   // 遍历输入数组的每个元素
   arr.forEach(item => {
+
+    
     switch (item.type) {
       case 'Element':
         // 对于Element类型，提取tableElementKey并包裹在E[]中
@@ -21,7 +23,7 @@ export function convertArrayToExpression(arr) {
         // 对于Text类型，直接使用name属性
         result.push(item.name);
         break;
-    case 'Brackets':
+     case 'Brackets':
         // 对于Text类型，直接使用name属性
         result.push(item.name);
         break;
@@ -123,7 +125,7 @@ export function formatArrayMore(inputArray) {
   return inputArray.map(item => processObject(item));
 }
 
-export function restoreArrayMore(processedArray, formulaDetailMap,remark) {
+export function restoreArrayMore(processedArray, formulaDetailMap, remark) {
   // 定义反转的字段映射关系（与原方法相反）
   const reverseMappings = {
       'parameter1': 'tag2',
@@ -166,7 +168,7 @@ export function restoreArrayMore(processedArray, formulaDetailMap,remark) {
       }
   };
   
-  // 解析表达式字符串为公式数组（修复符号与数字拆分问题）
+  // 解析表达式字符串为公式数组
   function parseExpressionToFormula(expression) {
       if (typeof expression !== 'string') return [];
       
@@ -175,7 +177,7 @@ export function restoreArrayMore(processedArray, formulaDetailMap,remark) {
       let currentPos = 0;
       
       // 定义所有运算符
-const operators = new Set(['+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|', '≥', '≤', '≠', '(', ')']);
+      const operators = new Set(['+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|', '≥', '≤', '≠', '(', ')']);
       
       // 检查是否为运算符
       const isOperatorChar = (char) => operators.has(char);
@@ -222,10 +224,7 @@ const operators = new Set(['+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|'
                   ft: operator,
                   template: { ft: operator },
                   name: operator,
-                  selected: false,
-                 
-                 
-                  
+                  selected: false
               });
           }
           // 处理文本（数字或其他字符）
@@ -247,7 +246,7 @@ const operators = new Set(['+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|'
                   formula.push({
                       type: 'Text',
                       name: text,
-                        selected: false,
+                      selected: false,
                   });
               }
               
@@ -270,51 +269,98 @@ const operators = new Set(['+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|'
   }
 
   // 还原单个对象的函数
-  function restoreObject(obj) {
-
+// 还原单个对象的函数
+function restoreObject(obj) {
+    const result = {};
+    
+    // 递归还原formulaIfElse（如果存在）
+    if (obj.formulaIfElse && Array.isArray(obj.formulaIfElse)) {
+        result.formulaIfElse = obj.formulaIfElse.map(item => {
+            const formulaItem = {};
+            // 处理parameter1
+            if (item.parameter1) {
+                const restoredValue = restoreValue(item.parameter1);
+                // 判断是否为E[]包裹的原生格式
+                if (item.parameter1.startsWith('E[')) {
+                    // 原生格式：设置tags2，清空tag2
+                    formulaItem.tags2 = [getTagElement(restoredValue)];
+                    formulaItem.tag2 = "";
+                } else {
+                    // 非原生格式：设置tag2，清空tags2
+                    formulaItem.tag2 = restoredValue;
+                    formulaItem.tags2 = [];
+                }
+            } else {
+                formulaItem.tags2 = [];
+                formulaItem.tag2 = "";
+            }
+            
+            // 处理parameter2
+            if (item.parameter2) {
+                const restoredValue = restoreValue(item.parameter2);
+                // 判断是否为E[]包裹的原生格式
+                if (item.parameter2.startsWith('E[')) {
+                    // 原生格式：设置tags3，清空tag3
+                    formulaItem.tags3 = [getTagElement(restoredValue)];
+                    formulaItem.tag3 = "";
+                } else {
+                    // 非原生格式：设置tag3，清空tags3
+                    formulaItem.tag3 = restoredValue;
+                    formulaItem.tags3 = [];
+                }
+            } else {
+                formulaItem.tags3 = [];
+                formulaItem.tag3 = "";
+            }
+            
+            // 处理其他字段（symbol、groupTerm等）
+            if (item.symbol) {
+                formulaItem.symbol1 = item.symbol;
+            }
+            if (item.groupTerm) {
+                formulaItem.logicSymbol = item.groupTerm;
+            }
+            
+            return formulaItem;
+        });
+    }
     
-      const result = {};
-      
-      // 递归还原formulaIfElse（如果存在）
-      if (obj.formulaIfElse && Array.isArray(obj.formulaIfElse)) {
-          result.formulaIfElse = obj.formulaIfElse.map(item => restoreObject(item));
-      }
-      
-      // 还原formula1和formula2
-      if (obj.trueData&&remark==='2') {
-          result.formula1 = parseExpressionToFormula(obj.trueData);
-      }
-      if (obj.falseData&&remark==='2') {
-          result.formula2 = parseExpressionToFormula(obj.falseData);
-      }
-      
-      // 处理参数与tags数组的还原
-      Object.keys(obj).forEach(key => {
-          const restoredValue = restoreValue(obj[key]);
-          
-          if (key === 'parameter1') {
-              result.tags2 = [getTagElement(restoredValue)];
-              result[reverseMappings[key]] = restoredValue;
-          }
-          else if (key === 'parameter2') {
-              result.tags3 = [getTagElement(restoredValue)];
-              result[reverseMappings[key]] = restoredValue;
-          }
-          else if (key === 'trueData') {
-              result.tags4 = [getTagElement(restoredValue)];
-              result[reverseMappings[key]] = restoredValue;
-          }
-          else if (key === 'falseData') {
-              result.tags5 = [getTagElement(restoredValue)];
-              result[reverseMappings[key]] = restoredValue;
-          }
-          else if (reverseMappings[key]) {
-              result[reverseMappings[key]] = restoredValue;
-          }
-      });
-      
-      return result;
-  }
+    // 根据remark值决定不同的还原逻辑
+    if (remark == 2) {
+        // 当remark等于2时：falseData/trueData还原成formula2/formula1
+        if (obj.trueData) {
+            result.formula1 = parseExpressionToFormula(obj.trueData);
+            result.tag4 = ""; // 清空tag4
+            result.tags4 = []; // 清空tags4数组
+        }
+        if (obj.falseData) {
+            result.formula2 = parseExpressionToFormula(obj.falseData);
+            result.tag5 = ""; // 清空tag5
+            result.tags5 = []; // 清空tags5数组
+        }
+    } else {
+        // 当remark不等于2时：falseData/trueData还原成tag4/tags4和tag5/tags5
+        if (obj.trueData) {
+            const restoredValue = restoreValue(obj.trueData);
+            result.tag4 = restoredValue;
+            result.tags4 = [getTagElement(restoredValue)];
+        } else {
+            result.tag4 = "";
+            result.tags4 = [];
+        }
+        
+        if (obj.falseData) {
+            const restoredValue = restoreValue(obj.falseData);
+            result.tag5 = restoredValue;
+            result.tags5 = [getTagElement(restoredValue)];
+        } else {
+            result.tag5 = "";
+            result.tags5 = [];
+        }
+    }
+    
+    return result;
+}
   
   // 还原整个数组
   return processedArray.map(item => restoreObject(item));