@ecip/ecip-web/src/utils/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) => {
  let valid = true
  if (min) {
    valid = min < value
  }
  if (max) {
    valid = max > value
  }
  return valid
}

// 字符串校验
const string = (rule, value, callback) => {
  if (isNaN(value)) {
    callback(new Error('只能填写数字'))
  }
  let valid = true
  if (rule.min) {
    valid = rule.minLength < value
  }
  if (rule.max) {
    valid = rule.maxLength > value
  }
  if (!valid) {
    const errorMsg = `${rule.minLength ? `值不能小于${rule.minLength}, ` : ''}${rule.maxLength ? `值不能大于${rule.maxLength}` : ''}`
    callback(new Error(errorMsg))
  }
  callback()
}

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

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

// 日期校验 element自带

// 日期ISO校验
const date = (rule, value, callback) => {
  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(value)) {
    callback(new Error('请输入正确的日期(ISO:yyyy-mm-dd或yyyy/mm/dd)'))
  }
  callback()
}

// 日期ISO校验
const dateISO = (rule, value, callback) => {
  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(value)) {
    callback(new Error('请输入正确的日期(ISO:yyyy-mm-dd或yyyy/mm/dd)'))
  }
  callback()
}

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

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

// 手机号码校验
const mobilePhoneNumber = (rule, value, callback) => {
  if (value == null || value === '') {
    callback()
  }
  const pattern = /^[1][3456789][0-9]{9}$/
  var reg = new RegExp(pattern)
  if (!reg.test(value)) {
    callback(new Error('手机号码格式校验失败'))
  }
  callback()
}

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

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

// 数字校验
const number = (rule, value, callback) => {
  if (isNaN(value)) {
    callback(new Error(`${value}不是数字`))
  }
  const valid = validMin_Max(rule.min, rule.max)
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ''}${rule.max ? `值不能大于${rule.max}` : ''}`
    callback(new Error(errorMsg))
  }
  callback()
}

// 整数校验
const integer = (rule, value, callback) => {
  const pattern = /^$|^-?\d+$/
  var reg = new RegExp(pattern)
  if (!reg.test(value)) {
    callback(new Error('请输入整数'))
  }
  const valid = validMin_Max(rule.min, rule.max)
  if (!valid) {
    const errorMsg = `${rule.min ? `值不能小于${rule.min}, ` : ''}${rule.max ? `值不能大于${rule.max}` : ''}`
    callback(new Error(errorMsg))
  }
  callback()
}

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

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

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

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

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

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

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

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

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

// 密码
const password = (rule, value, callback) => {
  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(value)) {
    callback(new Error('密码只能包含英文字符、数字和下划线'))
  }
  const valid = validMin_Max(minLength, maxLength, value.length)
  if (!valid) {
    const errorMsg = `${minLength ? `密码长度不能小于${minLength}, ` : ''}${maxLength ? `密码长度不能大于${maxLength}` : ''}`
    callback(new Error(errorMsg))
  }
  callback()
}

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

// 英语
const english = (rule, value, callback) => {
  const pattern = /^$|^[A-Za-z]+$/
  var reg = new RegExp(pattern)
  if (!reg.test(value)) {
    callback(new Error('请输入英文字符'))
  }
  callback()
}

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

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

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

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

const validator = {
  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 {
  validator,
  data() {
    return {
      validator
    }
  }
}