@ecip/ecip-web/src/utils/vxe-validators.js

A magical vue admin. An out-of-box UI solution for enterprise applications. Newest development stack of vue. Lots of awesome features

const validMin_Max = (min, max, value) => {
  if (!value) {
    return;
  }
  if (min < value) {
    return new Error(`值不能小于${min}`);
  }
  if (max > value) {
    return new Error(`值不能大于${max}`);
  }
};

// 字符串校验
const string = ({ cellValue, rule }) => {
  if (isNaN(cellValue)) {
    return new Error("只能填写数字");
  }
  if (rule && rule.min && rule.min < cellValue) {
    return new Error(`字符串长度不能小于${rule.min}`);
  }
  if (rule && rule.max && rule.max > cellValue) {
    return new Error(`字符串长度不能大于${rule.max}`);
  }
};

// 电子邮件校验
const email = ({ cellValue, rule }) => {
  const pattern =
    /^$|^([a-zA-Z0-9_\.\-])+@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,6})+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("邮箱格式不正确");
  }
};

// 网址校验
const website = ({ cellValue, rule }) => {
  const pattern = /^$|(^#)|(^http(s*):\/\/[^\s]+\.[^\s]+)/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的网址");
  }
};

// 日期校验 element自带

// 日期ISO校验
const date = ({ cellValue, rule }) => {
  const pattern =
    /^$|^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的日期(ISO:yyyy-mm-dd或yyyy/mm/dd)");
  }
};

// 日期ISO校验
const dateISO = ({ cellValue, rule }) => {
  const pattern =
    /^$|^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的日期(ISO:yyyy-mm-dd或yyyy/mm/dd)");
  }
};

// 信用卡号校验
const cardNumber = ({ cellValue, rule }) => {
  const pattern = /^(4\\d{12}(?:\\d{3})?)$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的信用卡号码");
  }
};

// 电话号码
const phoneNumber = ({ cellValue, rule }) => {
  const pattern = /^$|^(\d{3,4}-?)?\d{7,9}$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("电话号码格式校验失败");
  }
};

// 手机号码校验
const mobilePhoneNumber = ({ cellValue, rule }) => {
  const pattern = /^1\d{10}$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("手机号码格式校验失败");
  }
};

// 手机/电话校验
const mobilePhoneOrPhone = ({ cellValue, rule }) => {
  const pattern = /^$|^(((13[0-9]{1})|(15[0-9]{1})|(18[0-9]{1}))+\d{8})$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的手机/电话号码");
  }
};

// QQ号码校验
const qqNumber = ({ cellValue, rule }) => {
  const pattern = /^$|^[1-9]\d{4,12}$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的QQ号码");
  }
};
// 身份证号码校验
const idNumber = ({ cellValue, rule }) => {
  const pattern = /^$|(^\d{15}$)|(^\d{17}(x|X|\d)$)/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的身份证号");
  }
};

// 数字校验
const number = ({ cellValue, rule }) => {
  if (isNaN(cellValue)) {
    return new Error(`${cellValue}不是数字`);
  }
  validMin_Max(rule.min, rule.max, cellValue);
};

// 整数校验
const integer = ({ cellValue, rule }) => {
  const pattern = /^$|^-?\d+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入整数");
  }
  validMin_Max(rule.min, rule.max, cellValue);
};

// 整数（大于0）校验
const positiveInteger = ({ cellValue, rule }) => {
  const pattern = /^$|^[0-9]*[1-9][0-9]*$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写正整数（大于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 整数（大于等于0）校验
const nonNegativeInteger = ({ cellValue, rule }) => {
  const pattern = /^$|^\d+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写正整数（大于0）");
  }
  validMin_Max(rule.min, rule.max, cellValue);
};

// 整数（小于0）校验
const negativeInteger = ({ cellValue, rule }) => {
  const pattern = /^$|^-[0-9]*[1-9][0-9]*$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写整数（小于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 整数（小于等于0）校验
const nonPositiveInteger = ({ cellValue, rule }) => {
  const pattern = /^$|^((-\d+)|(0+))$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写整数（小于等于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 浮点数（大于0）校验
const positiveFloatingPoint = ({ cellValue, rule }) => {
  const pattern = /^$|^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写正浮点数（大于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 浮点数（大于等于0）校验
const nonNegativeFloatingPoint = ({ cellValue, rule }) => {
  const pattern = /^$|^\d+(\.\d+)?$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写非负浮点数（大于等于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 浮点数（小于0）校验
const negativeFloatingPoint = ({ cellValue, rule }) => {
  const pattern = /^$|^-[1-9]\d*\.\d*|-0\.\d*[1-9]\d*$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写负浮点数（小于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 浮点数（小于等于0）校验
const nonPositiveFloatingPoint = ({ cellValue, rule }) => {
  const pattern = /^$|^((-\d+(\.\d+)?)|(0+(\.0+)?))$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("只能填写非正浮点数（小于等于0）");
  }
  const valid = validMin_Max(rule.min, rule.max, cellValue);
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ""}${
      rule.max ? `值不能大于${rule.max}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 邮政编码
const postalCode = ({ cellValue, rule }) => {
  const pattern = /^$|^[0-9]{6}$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入正确的邮政编码");
  }
};

// 密码
const password = ({ cellValue, rule }) => {
  const minLength = rule.minLength || 6;
  const maxLength = rule.maxLength || 16;
  const pattern =
    /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z\\W]{minLength,maxLength}$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("密码只能包含英文字符、数字和下划线");
  }
  const valid = validMin_Max(minLength, maxLength, cellValue.length);
  if (!valid) {
    const errorMsg = `${minLength ? `密码长度不能小于${minLength}, ` : ""}${
      maxLength ? `密码长度不能大于${maxLength}` : ""
    }`;
    return new Error(errorMsg);
  }
};

// 中文/英文/数字/下划线
const chineseEnglishNumbersUnderlines = ({ cellValue, rule }) => {
  const pattern = /^$|^[a-zA-Z0-9\u4e00-\u9fa5-_]+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入中文/英文/数字/下划线");
  }
};

// 英语
const english = ({ cellValue }, xxx) => {
  // debugger
  const pattern = /^$|^[A-Za-z]+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入英文字符");
  }
};

// 汉字
const chinese = ({ cellValue, rule }) => {
  const pattern = /^$|^[\u4e00-\u9fa5]+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入中文字符");
  }
};

// 英汉字符
const englishOrChineseCharacters = ({ cellValue, rule }) => {
  const pattern = /^$|^[\u0391-\uFFE5]+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入英汉字符");
  }
};

// 合法字符
const legalCharacters = ({ cellValue, rule }) => {
  const pattern = /^$|^[A-Za-z0-9_-]+$/;
  var reg = new RegExp(pattern);
  if (!reg.test(cellValue)) {
    return new Error("请输入合法字符（a-zA-Z0-9）");
  }
};

// -----------------------------------------------------------------------------------

const vxeValidator = {
  string,
  email,
  website,
  date,
  dateISO,
  cardNumber,
  phoneNumber,
  mobilePhoneNumber,
  mobilePhoneOrPhone,
  qqNumber,
  idNumber,
  number,
  integer,
  positiveInteger,
  nonNegativeInteger,
  negativeInteger,
  nonPositiveInteger,
  positiveFloatingPoint,
  nonNegativeFloatingPoint,
  negativeFloatingPoint,
  nonPositiveFloatingPoint,
  postalCode,
  password,
  chineseEnglishNumbersUnderlines,
  english,
  chinese,
  englishOrChineseCharacters,
  legalCharacters,
};

export default {
  vxeValidator,
  data() {
    return {
      vxeValidator,
    };
  },
};