处理同一字段多个规则情况

 <!--
 <!--
  * @Date: 2022-07-18 10:22:22
  * @Date: 2022-07-18 10:22:22
  * @LastEditors: hookehuyr hookehuyr@gmail.com
  * @LastEditors: hookehuyr hookehuyr@gmail.com
- * @LastEditTime: 2024-02-22 16:32:46
+ * @LastEditTime: 2024-03-13 10:06:21
  * @FilePath: /data-table/src/views/index.vue
  * @FilePath: /data-table/src/views/index.vue
  * @Description: 首页
  * @Description: 首页
 -->
 -->
@@ -382,33 +382,84 @@ const checkUserPassword = () => {
   }
   }
 }
 }
 
 
+function mergeAndDeduplicate(data) {
+    return data.reduce((acc, current) => {
+        const existingItemIndex = acc.findIndex(item =>
+            item.mode === current.mode && item.logical_op === current.logical_op
+        );
+
+        if (existingItemIndex !== -1) {
+            // Merge expr_list values
+            acc[existingItemIndex].expr_list = acc[existingItemIndex].expr_list.concat(current.expr_list);
+        } else {
+            // Push new item to the accumulator
+            acc.push(current);
+        }
+
+        return acc;
+    }, []).map(item => {
+        // Remove duplicates from expr_list
+        item.expr_list = item.expr_list.filter((expr, index, self) =>
+            index === self.findIndex(e => (
+                e.op === expr.op && JSON.stringify(e.values) === JSON.stringify(expr.values) && e.field_name === expr.field_name
+            ))
+        );
+        return item;
+    });
+}
+
 // 根据规则隐藏相应字段
 // 根据规则隐藏相应字段
 const checkRules = () => {
 const checkRules = () => {
   const rule_list = formInfo.value['rule_list'] ? [...formInfo.value['rule_list']] : [];
   const rule_list = formInfo.value['rule_list'] ? [...formInfo.value['rule_list']] : [];
+  // TAG：处理同一字段多个规则情况
   formData.value.forEach(item => {
   formData.value.forEach(item => {
-    // 给受作用的字段绑定判断规则
-    // 规则失效需要踢出
+    item.x_rules = []; // 字段的规则
+  });
+
   rule_list.forEach(rule => {
   rule_list.forEach(rule => {
+    formData.value.forEach(item => {
       if (rule.field_names?.includes(item.key) && !rule.is_invalid) {
       if (rule.field_names?.includes(item.key) && !rule.is_invalid) {
-        item.field_rules = {
+        // 匹配字段的规则集合
+        item.x_rules.push({
           mode: rule.mode,
           mode: rule.mode,
           logical_op: rule.logical_op,
           logical_op: rule.logical_op,
           expr_list: rule.expr_list,
           expr_list: rule.expr_list,
+        })
       }
       }
-      }
+    })
   });
   });
+
+  formData.value.forEach(item => {
+    // 把规则合并，同一字段下的mode/logical_op必须一致
+    item.field_rules = mergeAndDeduplicate(item.x_rules)[0];
+  });
+
+  formData.value.forEach(item => {
+    // 给受作用的字段绑定判断规则
+    // 规则失效需要踢出
+    // rule_list.forEach(rule => {
+    //   if (rule.field_names?.includes(item.key) && !rule.is_invalid) {
+    //     item.field_rules = {
+    //       mode: rule.mode,
+    //       logical_op: rule.logical_op,
+    //       expr_list: rule.expr_list,
+    //     }
+    //   }
+    // });
     // 只检查存在规则的字段
     // 只检查存在规则的字段
     if (item.field_rules) {
     if (item.field_rules) {
       let condition = '';
       let condition = '';
       // 多个规则的满足条件，为全且或者全或
       // 多个规则的满足条件，为全且或者全或
       const op = item.field_rules?.logical_op === 'AND' ? '&&' : '||';
       const op = item.field_rules?.logical_op === 'AND' ? '&&' : '||';
       item.field_rules?.expr_list.forEach(expr => {
       item.field_rules?.expr_list.forEach(expr => {
-        if (typeof postData.value[expr['field_name']] === 'string') { // 表单值为字符串（单选，下拉）
-          const k = !!expr['values'].includes(postData.value[expr['field_name']])
-          condition += `${k}${op}`
-        }
-        if (typeof postData.value[expr['field_name']] === 'object') { // 表单值为数组（多选）
-          const k = !!(_.intersection(expr['values'], postData.value[expr['field_name']])).length;
+        let form_submission_value = postData.value[expr['field_name']]; // 表单提交值, field_12 : "" || field_13 : []
+        let rule_matching_value = expr['values']; // 规则匹配值 values : ['x']
+        if (typeof form_submission_value === 'string') { // 表单值为字符串（单选，下拉）
+          const k = !!rule_matching_value.includes(form_submission_value); // 转换为布尔值
+          condition += `${k}${op}`;
+        }
+        if (typeof form_submission_value === 'object') { // 表单值为数组（多选）
+          const k = !!(_.intersection(rule_matching_value, form_submission_value)).length; // 转换为布尔值
           condition += `${k}${op}`
           condition += `${k}${op}`
         }
         }
       });
       });
@@ -429,7 +480,7 @@ const checkRules = () => {
       }
       }
       item['component_props']['disabled'] = item.field_rules?.mode === 'SHOW' ? !condition : condition;
       item['component_props']['disabled'] = item.field_rules?.mode === 'SHOW' ? !condition : condition;
     }
     }
-  })
+  });
 }
 }
 
 
 // 操作绑定自定义字段回调
 // 操作绑定自定义字段回调