关于列表的表单效验---根据不同种类，效验范围不同

当前这个表单是一个列表数据，列表里面的item 

都要根据第一个参数值的具体类型，来设置第三个参数值的的数据范围

列如：

当前后台需要的传输的数据类型是如下：

[
  {
    "monitorType": "CpuUsageAmount",
    "operator": 1,
    "value": 1,
    "durationTime": 1,
    "frequencyTime": 10
  },
  {
    "durationTime": 1,
    "frequencyTime": 10,
    "monitorType": "NetworkReceiveBytes",
    "operator": 4,
    "value": 2
  },
  {
    "durationTime": 1,
    "frequencyTime": 10,
    "monitorType": "MemoryUsageRate",
    "operator": 4,
    "value": 3
  },
  {
    "durationTime": 1,
    "frequencyTime": 10,
    "monitorType": "NetworkTransmitPackets",
    "operator": 4,
    "value": 4
  },
  {
    "durationTime": 1,
    "frequencyTime": 10,
    "monitorType": "EventRestartPodNum",
    "operator": 4,
    "value": 5
  }
]

这样的列表

效验规则是要根据每一项里面的monitorType值，去效验value的数据范围

效验规则：

 
import { 
  validTriggerValue,
  validDurationTime
} from '@/utils/validate.js';





 data() {
    return {
      rulesRowItem: {
        allFrequencyTime: [
          { required: true, message: '请输入', trigger: 'blur' }
        ],
        monitorType: [{ required: true, message: '请输入', trigger: 'blur' }],
        operator: [{ required: false, message: '请输入', trigger: 'blur' }],
        value: [
          { required: true, message: '请输入', trigger: 'blur' },
          {
            validator: validTriggerValue.bind(this),
            message: '输入有误',
            trigger: ['blur']
          } 
        ],
        frequencyTime: [{ required: true, message: '请输入', trigger: 'blur' }],
        durationTime: [
          { required: true, message: '请填写', trigger: 'blur' },
          {
            validator: validDurationTime,
            trigger: ['blur']
          }
        ]
      }, 
      itemFrom: {},
      tempRowItem: {
        durationTime: 0,
        frequencyTime: 10,
        monitorType: '',
        operator: 0,
        value: 0
      }
    };
  },

具体规则是 validTriggerValue   是导出的一个方法，

因为要用到当前页面的其他数据值  所以需要绑定 this

//触发条件规则

export function validTriggerValue(rule, value, callback) {
  let conditions = this.itemFrom.triggerConditions;//获取整个表单的这个list 数组全部数据
  let index = rule.field.split(".")[1];// 根据当前触发规则的rule 找到是当前列表的第几项数据

  let reg = /^(\d+)$/;
  let reg1 = /^\d+(.\d{1,2})?$/;//效验规则的正则表达式
  if (value === "" || value === undefined || value == null) {
    return callback(new Error("请填写！"));
  } else {
    let condition = conditions[index];//根据这一项的monitorType值  来返回效验结果
    switch (condition.monitorType) {
      case "CpuUsageRate":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        } else {
          if (value <= 0 || value >= 100) {
            return callback(
              new Error("CPU利用率（100%）：只能输入大于0，小于100的数字")
            );
          } else {
            return callback();
          }
        }
        break;
      case "CpuUsageAmount":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 10000) {
          return callback(
            new Error("CPU使用量（核）：只能输入大于0，小于10,000的数字")
          );
        } else {
          return callback();
        }
        break;
      case "MemoryUsageAmount":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100000000) {
          return callback(
            new Error(
              "内存使用量（MBytes）：只能输入大于0，小于100,000,000的数字"
            )
          );
        } else {
          return callback();
        }
        break;

      case "MemoryUsageRate":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100) {
          return callback(
            new Error("内存使用率 （MBytes）：只能输入大于0，小于100的数字")
          );
        } else {
          return callback();
        }
        break;

      case "MemoryUsageAmountWithoutCache":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100000000) {
          return callback(
            new Error(
              "内存使用量（MBytes）：只能输入大于0，小于100,000,000的数字"
            )
          );
        } else {
          return callback();
        }
        break;

      case "MemoryUsageRateWithoutCache":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100) {
          return callback(
            new Error(
              "内存使用率（不包含cache）（MBytes）：只能输入大于0，小于100的数字"
            )
          );
        } else {
          return callback();
        }
        break;

      case "NetworkReceiveBytes":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100000000) {
          return callback(
            new Error(
              "网络入流量（MBytes）：只能输入大于0，小于100,000,000的数字"
            )
          );
        } else {
          return callback();
        }
        break;

      case "NetworkTransmitBytes":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 100000000) {
          return callback(
            new Error(
              "网络出流量（MBytes）：只能输入大于0，小于100,000,000的数字"
            )
          );
        } else {
          return callback();
        }
        break;

      case "NetworkReceiveBytesRate":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("网络入带宽（MBps）：只能输入大于0，小于1,000的数字")
          );
        } else {
          return callback();
        }
        break;

      case "NetworkTransmitBytesRate":
        if (!reg1.test(value)) {
          return callback(new Error("最多输入两位小数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("网络出带宽（MBps）：只能输入大于0，小于1,000的数字")
          );
        } else {
          return callback();
        }
        break;

      case "NetworkTransmitPackets":
        if (!reg.test(value)) {
          return callback(new Error("只能输入整数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("网络出包量（个/s）：只能输入大于0，小于1,000的数字")
          );
        } else {
          return callback();
        }
        break;

      case "NetworkReceivePackets":
        if (!reg.test(value)) {
          return callback(new Error("只能输入整数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("网络入包量（个/s）：只能输入大于0，小于1,000的数字。")
          );
        } else {
          return callback();
        }
        break;

      case "EventAbnormalPodNum":
        if (!reg.test(value)) {
          return callback(new Error("只能输入整数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("工作负载下Pod的异常个数：只能输入大于0，小于1,000的数字")
          );
        } else {
          return callback();
        }
        break;

      case "EventRestartPodNum":
        if (!reg.test(value)) {
          return callback(new Error("只能输入整数"));
        }
        if (value <= 0 || value >= 1000) {
          return callback(
            new Error("Pod重启次数：只能输入大于0，小于1,000的数字")
          );
        } else {
          return callback();
        }
        break;

      default:
        break;
    }

    return callback();
  }
}

这里的效验返回  正确的时候  也需要  return callback();