vue表单验证，多种校验规则

前言

vue 表单验证，具体的大家根据自身项目和框架来，本文以antd举例。

实现

• 这里以antd 举例

<template>
  <a-form-model ref="ruleForm" :model="form" :rules="rules" :label-col="labelCol" :wrapper-col="wrapperCol">
    <a-form-model-item ref="name" label="表单" prop="name">
      <a-input v-model="form.name"/>
    </a-form-model-item>
    <a-form-model-item :wrapper-col="{ span: 14, offset: 4 }">
      <a-button type="primary" @click="onSubmit">
        提交
      </a-button>
      <a-button style="margin-left: 10px;" @click="resetForm">
        重置
      </a-button>
    </a-form-model-item>
  </a-form-model>
</template>
<script>
// 引入了外部的验证规则
import {
      
       validatePhone} from "@/utils/validate";

export default {
      
      
  data() {
      
      
    return {
      
      
      labelCol: {
      
       span: 4 },
      wrapperCol: {
      
       span: 14 },
      other: '',
      form: {
      
      
        name: '',
      },
      rules: {
      
      
        name: [
          {
      
       required: true, message: 'Please input Activity name', trigger: 'blur' },
          {
      
       required: false, validator: validatePhone, trigger: 'blur' }
        ],
      },
    };
  },
  methods: {
      
      
    onSubmit() {
      
      
      this.$refs.ruleForm.validate(valid => {
      
      
        if (valid) {
      
      
          alert('submit!');
        } else {
      
      
          console.log('error submit!!');
          return false;
        }
      });
    },
    resetForm() {
      
      
      this.$refs.ruleForm.resetFields();
    },
  },
};
</script>

validate 自定义规则

• const：定义一个规则常量，常量名可变， ‘= (rule, value, callback) => {}’ 为固定格式，value 入参为验证的字段值

• rules -> name：表单验证中使用 validator 指定自定义校验规则常量名称

/* 是否手机号码*/
export function validatePhone(rule, value,callback) {
    
    
  const reg =/^[1][3,4,5,7,8][0-9]{9}$/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else {
    
    
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的电话号码'));
    } else {
    
    
      callback();
    }
  }
}

以下为 validate.js

// 身份证格式
export function idCardValidity(rule, code, callback) {
    
    
  var city = {
    
     11: "北京", 12: "天津", 13: "河北", 14: "山西", 15: "内蒙古", 21: "辽宁", 22: "吉林", 23: "黑龙江 ", 31: "上海", 32: "江苏", 33: "浙江", 34: "安徽", 35: "福建", 36: "江西", 37: "山东", 41: "河南", 42: "湖北 ", 43: "湖南", 44: "广东", 45: "广西", 46: "海南", 50: "重庆", 51: "四川", 52: "贵州", 53: "云南", 54: "西藏 ", 61: "陕西", 62: "甘肃", 63: "青海", 64: "宁夏", 65: "新疆", 71: "台湾", 81: "香港", 82: "澳门", 91: "国外 " };
  var tip = ""
  var pass = true
  if (!code || !/^\d{6}(18|19|20)?\d{2}(0[1-9]|1[012])(0[1-9]|[12]\d|3[01])\d{3}(\d|X)$/i.test(code)) {
    
    
    tip = "身份证号格式错误"
    pass = false;
  } else if (!city[code.substr(0, 2)]) {
    
    
    tip = "地址编码错误"
    pass = false
  } else {
    
    
    // 18位身份证需要验证最后一位校验位
    if (code.length === 18) {
    
    
      code = code.split('')
      // ∑(ai×Wi)(mod 11)
      // 加权因子
      var factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
      // 校验位
      var parity = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2]
      var sum = 0
      var ai = 0
      var wi = 0
      for (var i = 0; i < 17; i++) {
    
    
        ai = code[i]
        wi = factor[i]
        sum += ai * wi
      }
      var last = parity[sum % 11];
      if (parity[sum % 11] != code[17]) {
    
    
        tip = "校验位错误"
        pass = false
      }
    }
  }
  if (!pass) {
    
    
    callback(new Error(tip))
  } else {
    
    
    callback()
  }
}

/* 是否合法IP地址 */
export function validateIP(rule, value,callback) {
    
    
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else {
    
    
    const reg = /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/;
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的IP地址'));
    } else {
    
    
      callback();
    }
  }
}

/* 是否手机号码或者固话 */
export function validatePhoneTwo(rule, value, callback) {
    
    
  const reg = /^((0\d{2,3}-\d{7,8})|(1[34578]\d{9}))$/;;
  if (value == '' || value == undefined || value == null) {
    
    
    callback();
  } else {
    
    
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的电话号码或者固话号码'));
    } else {
    
    
      callback();
    }
  }
}

/* 是否固话 */
export function validateTelphone(rule, value,callback) {
    
    
  const reg =/0\d{2}-\d{7,8}/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else {
    
    
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的固话（格式：区号+号码,如010-1234567）'));
    } else {
    
    
      callback();
    }
  }
}

/* 是否手机号码*/
export function validatePhone(rule, value,callback) {
    
    
  const reg =/^[1][3,4,5,7,8][0-9]{9}$/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else {
    
    
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的电话号码'));
    } else {
    
    
      callback();
    }
  }
}

/* 是否身份证号码 */
export function validateIdNo(rule, value,callback) {
    
    
  const reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else {
    
    
    if ((!reg.test(value)) && value != '') {
    
    
      callback(new Error('请输入正确的身份证号码'));
    } else {
    
    
      callback();
    }
  }
}

/* 是否邮箱 */
export function validateEMail(rule, value,callback) {
    
    
  const reg =/^([a-zA-Z0-9]+[-_\.]?)+@[a-zA-Z0-9]+\.[a-z]+$/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  }else{
    
    
    if (!reg.test(value)){
    
    
      callback(new Error('请输入正确的邮箱地址'));
    } else {
    
    
      callback();
    }
  }
}

/* 合法uri */
export function validateURL(textval) {
    
    
  const urlregex = /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/;
  return urlregex.test(textval);
}

/* 验证内容是否英文数字以及下划线 */
export function isPassword(rule, value, callback) {
    
    
  const reg =/^[_a-zA-Z0-9]+$/;
  if(value==''||value==undefined||value==null){
    
    
    callback();
  } else {
    
    
    if (!reg.test(value)){
    
    
      callback(new Error('密码仅由英文字母，数字以及下划线组成'));
    } else {
    
    
      callback();
    }
  }
}

/* 自动检验数值的范围 */
export function checkMax20000(rule, value, callback) {
    
    
  if (value == '' || value == undefined || value == null) {
    
    
    callback();
  } else if (!Number(value)) {
    
    
    callback(new Error('请输入[1,20000]之间的数字'));
  } else if (value < 1 || value > 20000) {
    
    
    callback(new Error('请输入[1,20000]之间的数字'));
  } else {
    
    
    callback();
  }
}

// 验证数字输入框最大数值,32767
export function checkMaxVal(rule, value,callback) {
    
    
  if (value < 0 || value > 32767) {
    
    
    callback(new Error('请输入[0,32767]之间的数字'));
  } else {
    
    
    callback();
  }
}

// 验证是否1-99之间
export function isOneToNinetyNine(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入正整数'));
    } else {
    
    
      const re = /^[1-9][0-9]{0,1}$/;
      const rsCheck = re.test(value);
      if (!rsCheck) {
    
    
        callback(new Error('请输入正整数，值为【1,99】'));
      } else {
    
    
        callback();
      }
    }
  }, 0);
}

// 验证是否整数
export function isInteger(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入正整数'));
    } else {
    
    
      const re = /^[0-9]*[1-9][0-9]*$/;
      const rsCheck = re.test(value);
      if (!rsCheck) {
    
    
        callback(new Error('请输入正整数'));
      } else {
    
    
        callback();
      }
    }
  }, 0);
}

// 验证是否整数,非必填
export function isIntegerNotMust(rule, value, callback) {
    
    
  if (!value) {
    
    
    callback();
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入正整数'));
    } else {
    
    
      const re = /^[0-9]*[1-9][0-9]*$/;
      const rsCheck = re.test(value);
      if (!rsCheck) {
    
    
        callback(new Error('请输入正整数'));
      } else {
    
    
        callback();
      }
    }
  }, 1000);
}

// 验证是否是[0-1]的小数
export function isDecimal(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入[0,1]之间的数字'));
    } else {
    
    
      if (value < 0 || value > 1) {
    
    
        callback(new Error('请输入[0,1]之间的数字'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

// 验证是否是[1-10]的小数,即不可以等于0
export function isBtnOneToTen(rule, value, callback) {
    
    
  if (typeof value == 'undefined') {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入正整数，值为[1,10]'));
    } else {
    
    
      if (!(value == '1' || value == '2' || value == '3' || value == '4' || value == '5' || value == '6' || value == '7' || value == '8' || value == '9' || value == '10')) {
    
    
        callback(new Error('请输入正整数，值为[1,10]'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

// 验证是否是[1-100]的小数,即不可以等于0
export function isBtnOneToHundred(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入整数，值为[1,100]'));
    } else {
    
    
      if (value < 1 || value > 100) {
    
    
        callback(new Error('请输入整数，值为[1,100]'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

// 验证是否是[0-100]的小数
export function isBtnZeroToHundred(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (!Number(value)) {
    
    
      callback(new Error('请输入[1,100]之间的数字'));
    } else {
    
    
      if (value < 0 || value > 100) {
    
    
        callback(new Error('请输入[1,100]之间的数字'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

// 验证端口是否在[0,65535]之间
export function isPort(rule, value, callback) {
    
    
  if (!value) {
    
    
    return callback(new Error('输入不可以为空'));
  }
  setTimeout(() => {
    
    
    if (value == '' || typeof(value) == undefined) {
    
    
      callback(new Error('请输入端口值'));
    } else {
    
    
      const re = /^([0-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/;
      const rsCheck = re.test(value);
      if (!rsCheck) {
    
    
        callback(new Error('请输入在[0-65535]之间的端口值'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

// 验证端口是否在[0,65535]之间，非必填,isMust表示是否必填
export function isCheckPort(rule, value, callback) {
    
    
  if (!value) {
    
    
    callback();
  }
  setTimeout(() => {
    
    
    if (value == '' || typeof(value) == undefined) {
    
    
      //callback(new Error('请输入端口值'));
    } else {
    
    
      const re = /^([0-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/;
      const rsCheck = re.test(value);
      if (!rsCheck) {
    
    
        callback(new Error('请输入在[0-65535]之间的端口值'));
      } else {
    
    
        callback();
      }
    }
  }, 100);
}

/* 小写字母 */
export function validateLowerCase(str) {
    
    
  const reg = /^[a-z]+$/;
  return reg.test(str);
}

/* 大写字母*/
export function validateUpperCase(str) {
    
    
  const reg = /^[A-Z]+$/;
  return reg.test(str);
}

/* 大小写字母*/
export function validatAlphabets(str) {
    
    
  const reg = /^[A-Za-z]+$/;
  return reg.test(str);
}