修复找不到ft问题

src/views/formula/formulaArrayToString.js

@@ -4,6 +4,119 @@ function isFormulaItem(ele){
 }
 
 //转换公式的参数
+// function transformArguments(children,curEle,eleMap){
+//   let fcReg = /(FC\.\S+\()(.+)\)/;
+//   let fcText = '';
+//   for (let i = (children.length-1); i >= 0; i--) {
+//     let ele = children[i];
+
+//     if(ele.isOn === false){
+//       //点击了开关关闭的，跳过
+//       continue;
+//     }
+//     //console.log(ele.name)
+//     let tmpArr = fcReg.exec(ele.template.ft);
+//     fcText = tmpArr[1] + fcText;//fc.XX( 左括号部分
+//     let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
+//     let isNestEle = false;//是否有过嵌套的元素了
+//     let isNestEle2 = false;
+//     //console.log(argList)
+//     //console.log(text)
+//     argList.forEach((argText,index)=>{
+//       if(argText.indexOf('#')>-1){
+//         //#动态参数
+//         let argIndex = index;
+//         for (let j = 0; j < ele.template.args.length; j++) {
+//           if(ele.template.args[j].key == argText){
+//             //找到相同的#编码
+//             argIndex = j;
+//             break;
+//           }
+//         }
+//         let arg = ele.arguments[argIndex];
+        
+//         if(arg && isFormulaItem(arg)){
+//           if(!isNestEle && !isNestEle2 && i != (children.length-1) && curEle.id == arg.id){
+//             //不是第一个嵌套的公式，且和当前挂载的是同一个元素
+//             //认为这个参数是之前公式计算的结果，不再写入元素
+//             isNestEle = true;
+//           }else{
+//             if(arg.type == 'Element'){
+//               eleMap[arg.tableElementKey] = {
+//                 id: arg.id,
+//                 name: arg.name,
+//                 tableElementKey: arg.tableElementKey,
+//                 type: "Element",
+//               };
+//               fcText += `E[${arg.tableElementKey}]`;
+//             }else if(arg.type == 'ParamData'){
+//               eleMap[arg.k] = {
+//                 id: arg.id,
+//                 name: arg.name,
+//                 v:arg.v,
+//                 k:arg.k,
+//                 type: "ParamData",
+//               };
+//               fcText += `WP[${arg.k}]`;
+//             }
+            
+//           }
+//         }else if(Array.isArray(arg)){
+//           //ifsles方法会进来
+//           arg.forEach((a)=>{
+//             if(a && isFormulaItem(a)){
+//               if(!isNestEle2 && i != (children.length-1) && curEle.id == a.id){
+//                 //不是第一个嵌套的公式，且和当前挂载的是同一个元素
+//                 //认为这个参数是之前公式计算的结果，不再写入元素
+//                 isNestEle2 = true
+//               }else{
+//                 if(a.type == 'Element'){
+//                   eleMap[a.tableElementKey] = {
+//                     id: a.id,
+//                     name: a.name,
+//                     tableElementKey: a.tableElementKey,
+//                     type: "Element",
+//                   };
+//                   fcText += `E[${a.tableElementKey}]`;
+//                 }else if(a.type == 'ParamData'){
+//                   eleMap[a.k] = {
+//                     id: a.id,
+//                     name: a.name,
+//                     v:a.v,
+//                     k:a.k,
+//                     type: "ParamData",
+//                   };
+//                   fcText += `WP[${a.k}]`;
+//                 }
+//               }
+//             }else if(a && a.type == 'Operator'){
+//               //在运算符前后加上空格
+//               fcText += ' '+a.name+' ';
+//               //console.log(fcText)
+//             }else if(a && a.type){
+//               fcText += a.name;
+//             }else{
+//               fcText += a?a:"''";
+//             }
+//           })
+
+//         }else{
+//           fcText += arg?arg:"''";
+//         }
+
+//       }else{
+//         //已有参数
+//         fcText += argText?argText:'';
+//       }
+//       if(index != argList.length-1){
+//         fcText += ',';
+//       }
+//     })
+//     fcText += ')';
+//   }
+
+//   return fcText;
+// }
 function transformArguments(children,curEle,eleMap){
   let fcReg = /(FC\.\S+\()(.+)\)/;
   let fcText = '';
@@ -14,110 +127,115 @@ function transformArguments(children,curEle,eleMap){
       //点击了开关关闭的，跳过
       continue;
     }
-    //console.log(ele.name)
-    let tmpArr = fcReg.exec(ele.template.ft);
-    fcText = tmpArr[1] + fcText;//fc.XX( 左括号部分
-    let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
-    let isNestEle = false;//是否有过嵌套的元素了
-    let isNestEle2 = false;
-    //console.log(argList)
-    //console.log(text)
-    argList.forEach((argText,index)=>{
-      if(argText.indexOf('#')>-1){
-        //#动态参数
-        let argIndex = index;
-        for (let j = 0; j < ele.template.args.length; j++) {
-          if(ele.template.args[j].key == argText){
-            //找到相同的#编码
-            argIndex = j;
-            break;
-          }
-        }
-        let arg = ele.arguments[argIndex];
-        
-        if(arg && isFormulaItem(arg)){
-          if(!isNestEle && !isNestEle2 && i != (children.length-1) && curEle.id == arg.id){
-            //不是第一个嵌套的公式，且和当前挂载的是同一个元素
-            //认为这个参数是之前公式计算的结果，不再写入元素
-            isNestEle = true;
-          }else{
-            if(arg.type == 'Element'){
-              eleMap[arg.tableElementKey] = {
-                id: arg.id,
-                name: arg.name,
-                tableElementKey: arg.tableElementKey,
-                type: "Element",
-              };
-              fcText += `E[${arg.tableElementKey}]`;
-            }else if(arg.type == 'ParamData'){
-              eleMap[arg.k] = {
-                id: arg.id,
-                name: arg.name,
-                v:arg.v,
-                k:arg.k,
-                type: "ParamData",
-              };
-              fcText += `WP[${arg.k}]`;
+    if (ele.template != null && ele.template != undefined) {
+      let tmpArr = fcReg.exec(ele.template.ft);
+      fcText = tmpArr[1] + fcText;//fc.XX( 左括号部分
+      let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
+      let isNestEle = false;//是否有过嵌套的元素了
+      let isNestEle2 = false;
+      //console.log(argList)
+      //console.log(text)
+      argList.forEach((argText,index)=>{
+        if(argText.indexOf('#')>-1){
+          //#动态参数
+          let argIndex = index;
+          for (let j = 0; j < ele.template.args.length; j++) {
+            if(ele.template.args[j].key == argText){
+              //找到相同的#编码
+              argIndex = j;
+              break;
             }
-            
           }
-        }else if(Array.isArray(arg)){
-          //ifsles方法会进来
-          arg.forEach((a)=>{
-            if(a && isFormulaItem(a)){
-              if(!isNestEle2 && i != (children.length-1) && curEle.id == a.id){
-                //不是第一个嵌套的公式，且和当前挂载的是同一个元素
-                //认为这个参数是之前公式计算的结果，不再写入元素
-                isNestEle2 = true
-              }else{
-                if(a.type == 'Element'){
-                  eleMap[a.tableElementKey] = {
-                    id: a.id,
-                    name: a.name,
-                    tableElementKey: a.tableElementKey,
-                    type: "Element",
-                  };
-                  fcText += `E[${a.tableElementKey}]`;
-                }else if(a.type == 'ParamData'){
-                  eleMap[a.k] = {
-                    id: a.id,
-                    name: a.name,
-                    v:a.v,
-                    k:a.k,
-                    type: "ParamData",
-                  };
-                  fcText += `WP[${a.k}]`;
-                }
-              }
-            }else if(a && a.type == 'Operator'){
-              //在运算符前后加上空格
-              fcText += ' '+a.name+' ';
-              //console.log(fcText)
-            }else if(a && a.type){
-              fcText += a.name;
+          let arg = ele.arguments[argIndex];
+          
+          if(arg && isFormulaItem(arg)){
+            if(!isNestEle && !isNestEle2 && i != (children.length-1) && curEle.id == arg.id){
+              //不是第一个嵌套的公式，且和当前挂载的是同一个元素
+              //认为这个参数是之前公式计算的结果，不再写入元素
+              isNestEle = true;
             }else{
-              fcText += a?a:"''";
+              if(arg.type == 'Element'){
+                eleMap[arg.tableElementKey] = {
+                  id: arg.id,
+                  name: arg.name,
+                  tableElementKey: arg.tableElementKey,
+                  type: "Element",
+                };
+                fcText += `E[${arg.tableElementKey}]`;
+              }else if(arg.type == 'ParamData'){
+                eleMap[arg.k] = {
+                  id: arg.id,
+                  name: arg.name,
+                  v:arg.v,
+                  k:arg.k,
+                  type: "ParamData",
+                };
+                fcText += `WP[${arg.k}]`;
+              }
+              
             }
-          })
-
+          }else if(Array.isArray(arg)){
+            //ifsles方法会进来
+            arg.forEach((a)=>{
+              if(a && isFormulaItem(a)){
+                if(!isNestEle2 && i != (children.length-1) && curEle.id == a.id){
+                  //不是第一个嵌套的公式，且和当前挂载的是同一个元素
+                  //认为这个参数是之前公式计算的结果，不再写入元素
+                  isNestEle2 = true
+                }else{
+                  if(a.type == 'Element'){
+                    eleMap[a.tableElementKey] = {
+                      id: a.id,
+                      name: a.name,
+                      tableElementKey: a.tableElementKey,
+                      type: "Element",
+                    };
+                    fcText += `E[${a.tableElementKey}]`;
+                  }else if(a.type == 'ParamData'){
+                    eleMap[a.k] = {
+                      id: a.id,
+                      name: a.name,
+                      v:a.v,
+                      k:a.k,
+                      type: "ParamData",
+                    };
+                    fcText += `WP[${a.k}]`;
+                  }
+                }
+              }else if(a && a.type == 'Operator'){
+                //在运算符前后加上空格
+                fcText += ' '+a.name+' ';
+                //console.log(fcText)
+              }else if(a && a.type){
+                fcText += a.name;
+              }else{
+                fcText += a?a:"''";
+              }
+            })
+  
+          }else{
+            fcText += arg?arg:"''";
+          }
+  
         }else{
-          fcText += arg?arg:"''";
+          //已有参数
+          fcText += argText?argText:'';
         }
+        if(index != argList.length-1){
+          fcText += ',';
+        }
+      })
+    
+      fcText += ')';
+    
+    }
+    //console.log(ele.name)
 
-      }else{
-        //已有参数
-        fcText += argText?argText:'';
-      }
-      if(index != argList.length-1){
-        fcText += ',';
-      }
-    })
-    fcText += ')';
+  
   }
 
   return fcText;
 }
-
 export const formulaArrayToString = (processFormula,resultFormula) => {
   let text = '';
   let eleMap = {};//元素字典，为了回显的时候查询信息

src/views/formula/formulaStringToArray.js

@@ -17,19 +17,20 @@ function parseFormula(arr,resultFormula,processFormula,isAllFun){
       parseFormula(arr[i].children,resultFormula,processFormula,isAllFun);
     }
   }else{
-    for (let i = 0; i < tmpArr.length; i++) {
-      if(tmpArr[i].type == 'Function'){
+    for (let j = 0; j < tmpArr.length; j++) {
+      let data = tmpArr[j];
+      if(data.type == 'Function'){
         let obj = {
           children:[],
           name:"临时占位",
           selected:false,
           type:"Element",
         }
-        parseProcessFormula(arr[i],obj);
+        parseProcessFormula(arr[j],obj);
         processFormula.push(Object.assign({},obj))
         delete obj.children;
-      }else if(tmpArr[i].name){
-        processFormula.push(tmpArr[i]);
+      }else if(data.name){
+        processFormula.push(data);
       }
     }
   }
@@ -64,38 +65,40 @@ function parseArguments(ele,funObj){
 
   fun.arguments = [];
 
-  let tmpArr = fcReg.exec(funObj.template.ft);
-  let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
-
-  argList.forEach((argText,index)=>{
-      //只用动态的
-      if(argText.indexOf('#')>-1){
-        if(argSpliceArr[index].length>1){
-          if(fun.name == '判断'){
-            fun.arguments.push(ifFunArgumentsHandle(argSpliceArr[index]))
+  if (funObj.template != null && funObj.template != undefined) {
+    let tmpArr = fcReg.exec(funObj.template.ft);
+    let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
+
+    argList.forEach((argText,index)=>{
+        //只用动态的
+        if(argText.indexOf('#')>-1){
+          if(argSpliceArr[index].length>1){
+            if(fun.name == '判断'){
+              fun.arguments.push(ifFunArgumentsHandle(argSpliceArr[index]))
+            }else{
+              //是前面的计算结果
+              fun.arguments.push(ele)
+            }
+  
           }else{
-            //是前面的计算结果
-            fun.arguments.push(ele)
-          }
-
-        }else{
-          let arg = argSpliceArr[index][0];
-          if(!arg){
-            fun.arguments.push(undefined)
-          }else if( arg.type == 'Element'){
-            fun.arguments.push(arg)
-          }else if( arg.type == 'ParamData'){
-            fun.arguments.push(arg)
-          }else if(arg.type == 'Function'){
-            fun.arguments.push(ele)
-          }else if(arg.type == 'Text'){
-            fun.arguments.push(arg.tag)
-          }else{
-            fun.arguments.push(undefined)
+            let arg = argSpliceArr[index][0];
+            if(!arg){
+              fun.arguments.push(undefined)
+            }else if( arg.type == 'Element'){
+              fun.arguments.push(arg)
+            }else if( arg.type == 'ParamData'){
+              fun.arguments.push(arg)
+            }else if(arg.type == 'Function'){
+              fun.arguments.push(ele)
+            }else if(arg.type == 'Text'){
+              fun.arguments.push(arg.tag)
+            }else{
+              fun.arguments.push(undefined)
+            }
           }
         }
-      }
-    })
+      })  
+  }
 
   ele.children.push(fun);
 }
@@ -427,9 +430,9 @@ export const formulaStringToArray = (text,elemap,formulaMap) => {
   parseFormula(resArr,resultFormula,processFormula,isAllFun);
 
   //console.log(contentStack)
-  console.log(resArr);
-  console.log(resultFormula);
-  console.log(processFormula);
+  console.log(resArr, "--------- resArr -------");
+  console.log(resultFormula, "--------- resultFormula -------");
+  console.log(processFormula, "--------- processFormula -------");
 
   return {
     processFormula:processFormula,