vue正则，各种正则表达式

已于 2023-12-13 18:03:41 修改
阅读量4.5k 收藏 25
点赞数 4
文章标签： vue.js 正则表达式 前端
于 2020-11-20 18:05:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45563734/article/details/109328969
版权

vue正则，各种正则表达式

1. 直接上代码

/* 合法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)
}
/**
 * 邮箱
 * @param {*} s
 */
export function isEmail(s) {
    return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s)
}

/**
 * 手机号码
 * @param {*} s
 */
export function isMobile(s) {
    return /^1[0-9]{10}$/.test(s)
}

/**
 * 电话号码
 * @param {*} s
 */
export function isPhone(s) {
    return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s)
}

/**
 * URL地址
 * @param {*} s
 */
export function isURL(s) {
    return /^http[s]?:\/\/.*/.test(s)
}

/* 小写字母*/
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)
}
/*验证pad还是pc*/
export const vaildatePc = function() {
        const userAgentInfo = navigator.userAgent;
        const Agents = ["Android", "iPhone",
            "SymbianOS", "Windows Phone",
            "iPad", "iPod"
        ];
        let flag = true;
        for (var v = 0; v < Agents.length; v++) {
            if (userAgentInfo.indexOf(Agents[v]) > 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    /**
     * validate email
     * @param email
     * @returns {boolean}
     */
export function validateEmail(email) {
    const re = /^(([^<>()\\[\]\\.,;:\s@"]+(\.[^<>()\\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    return re.test(email)
}

/**
 * 判断身份证号码
 */
export function cardid(code) {
    let list = [];
    let result = true;
    let msg = '';
    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: "国外 "
    };
    if (!validatenull(code)) {
        if (code.length == 18) {
            if (!code || !/(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(code)) {
                msg = "证件号码格式错误";
            } else if (!city[code.substr(0, 2)]) {
                msg = "地址编码错误";
            } else {
                //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, 'x'];
                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;
                }
                if (parity[sum % 11] != code[17]) {
                    msg = "证件号码校验位错误";
                } else {
                    result = false;
                }

            }
        } else {
            msg = "证件号码长度不为18位";
        }

    } else {
        msg = "证件号码不能为空";
    }
    list.push(result);
    list.push(msg);
    return list;
}
/**
 * 判断手机号码是否正确
 */
export function isvalidatemobile(phone) {
    let list = [];
    let result = true;
    let msg = '';
    var isPhone = /^0\d{2,3}-?\d{7,8}$/;
    //增加134 减少|1349[0-9]{7}，增加181,增加145，增加17[678]  
    if (!validatenull(phone)) {
        if (phone.length == 11) {
            if (isPhone.test(phone)) {
                msg = 'login.hintIncorrectFormat';
            } else {
                result = false;
            }
        } else {
            msg = 'login.hintPhonLength';
        }
    } else {
        msg = "login.hintNotEmpty" //'手机号码不能为空';
    }
    list.push(result);
    list.push(msg);
    return list;
}
/**
 * 判断姓名是否正确
 */
export function validatename(name) {
    var regName = /^[\u4e00-\u9fa5]{2,4}$/;
    if (!regName.test(name)) return false;
    return true;
}
/**
 * 判断是否为整数
 */
export function validatenum(num, type) {
    let regName = /[^\d.]/g;
    if (type == 1) {
        if (!regName.test(num)) return false;
    } else if (type == 2) {
        regName = /[^\d]/g;
        if (!regName.test(num)) return false;
    }
    return true;
}
/**
 * 判断是否为小数
 */
export function validatenumord(num, type) {
    let regName = /[^\d.]/g;
    if (type == 1) {
        if (!regName.test(num)) return false;
    } else if (type == 2) {
        regName = /[^\d.]/g;
        if (!regName.test(num)) return false;
    }
    return true;
}
/**
 * 判断是否为空
 */
export function validatenull(val) {
    if (typeof val == 'boolean') {
        return false;
    }
    if (typeof val == 'number') {
        return false;
    }
    if (val instanceof Array) {
        if (val.length == 0) return true;
    } else if (val instanceof Object) {
        if (JSON.stringify(val) === '{}') return true;
    } else {
        if (val == 'null' || val == null || val == 'undefined' || val == undefined || val == '') return true;
        return false;
    }
    return false;
}

// 邮箱
extend("email", value => {
  //let re = /^([a-zA-Z0-9]+[_|\-|\.]?)+@([a-zA-Z0-9]+[_|\-|\.]?)+([a-zA-Z0-9]{1,})+\.[a-zA-Z]{2,}$/;
  // let re = /^[a-zA-Z0-9_-|\.|\-]+@[a-zA-Z0-9_-|\.|\-]+(\.[a-zA-Z]+)+$/;
  let re = /^([a-zA-Z]|[0-9])(\w|\-)+@[a-zA-Z0-9]+\.([a-zA-Z]{2,4})$/;
  if (!re.test(value)) {
    return "请输入正确的{_field_}";
  } else if (value.length > 50) {
    return "{_field_}不能超过50个字符";
  } else {
    return true;
  }
});
// 两次输入密码不一致
extend("confirmed", {
  ...confirmed,
  message: "两次密码输入不一致"
});

//输入框不为空
extend("required", {
  ...required,
  message: "请输入{_field_}"
});
//账号不支持中文 只能以字母开头 长度为6-32个字符 至少包含英文字母、数字或特殊字符(-_)中的两种
extend("eNameNum", value => {
  //let re = /(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]{8,12}/;
  let re = /^[a-zA-Z][\w\(\)\-]{6,32}$/;
  let reg = /^[A-Za-z]+$/;
  if (re.test(value) && !reg.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由6~32位大/小写字母，数字组合)";
});
//下拉框不为空
extend("selected", {
  ...required,
  message: "请选择{_field_}"
});
//复选框不为空
extend("checked", {
  ...required,
  message: "请勾选{_field_}"
});

//数字和字母
extend("alpha_num", {
  ...required,
  message: "只能输入数字和字母"
});
//最小
extend("min", {
  validate(value, args) {
    return value.toString().length >= args.length;
  },
  params: ["length"],
  message: "长度不能少于 {length} 个字符"
});
//最大
extend("max", {
  validate(value, args) {
    return value.toString().length <= args.length;
  },
  params: ["length"],
  message: "长度不能超过 {length} 个字符"
});

//上传文件不能为空
extend("file", {
  ...required,
  message: "请上传{_field_}"
});
// 字段最大字符，提示里面还有字段label，maxHasLabel:20
extend("maxHasLabel", {
  validate(value, args) {
    return value.length <= args.length;
  },
  params: ["length"],
  message: "{_field_}不能超过{length}个字符"
});

// 区间范围 只能输入区间的字母或数字
extend("section", {
  validate(value, args) {
    let temp = args.section.split("-");
    if (value.length >= temp[0] && value.length <= temp[1]) {
      return /^[0-9a-zA-Z]*$/g.test(value);
    }
    return false;
  },
  params: ["section"],
  message: "请输入{section}位数字或字母"
});

//3.自定义
extend("num", value => {
  let re = /^[0-9]+$/;
  if (re.test(value)) {
    return true;
  }
  return "只能输入数字";
});
//大于1的正整数
extend("nums", value => {
  let re = /^\+?[1-9]\d*$/;
  if (re.test(value)) {
    return true;
  }
  return "只能输入大于0的正整数";
});
//只能输入数字,切保留两位小数
extend("numss", value => {
  let re = /^\d+(\.\d{1,2})?$/;
  if (re.test(value) && Number(value) > 0) {
    return true;
  }
  return "只能输入大于0的数字,且保留两位小数";
});
//正确的url跳转地址
extend("url", value => {
  let re = /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的产品地址";
});
//手机号
extend("mobile", value => {
  let re = /^1[3456789]\d{9}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的手机号码";
});

//手机号（仅供api管理服务应用使用）
extend("mobiles", value => {
  let re = /^1[0123456789]\d{9}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的手机号码";
});

//菜单编码,MENU+6位数字
extend("menuCode", value => {
  let re = /^MENU\d{6}$/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}格式错误";
});

//菜单顺序，仅1-8位正整数
extend("menuOrder", value => {
  let re = /^[1-9]\d{0,7}$/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}格式错误";
});
extend("eNameNum", value => {
  //let re = /(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]{8,12}/;
  let re = /^[a-zA-Z][\w\(\)\-]{6,32}$/;
  let reg = /^[A-Za-z]+$/;
  if (re.test(value) && !reg.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由6~32位大/小写字母，数字组合)";
});
//连接地址:http://* | https://*
extend("httpUrl", value => {
  let re = /^(http|https):\/\/([\w.]+\/?)\S/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}格式错误";
});
//url地址，可以不用http开头
extend("looseUrl", value => {
  let re = /^((http|https):\/\/)?([\w.]+\/?)\S/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}格式错误";
});
//8-32位带大小写，数字，特殊字符任意两种 (?!([^(0-9a-zA-Z)])+$)
extend("checkPassword", value => {
  // let re = /^(?![0-9]+$)(?![a-z]+$)(?![A-Z]+$)(?!([^(0-9a-zA-Z)])+$).{8,32}$/;
  var re = /^(?![A-Z]+$)(?![a-z]+$)(?!\d+$)(?![\W_]+$)\S{8,32}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入8-32个字符,至少包含大写字母、小写字母、数字和特殊字符中的两种";
});

//不能输入中文
extend("notChinese", value => {
  let re = /^[^\u4e00-\u9fa5]+$/;
  if (re.test(value)) {
    return true;
  }
  return "不能包含中文";
});

//由中文字符、英文字母、数字、中划线、下划线/.
extend("mixedInput", value => {
  let re = /^[\u4e00-\u9fa5_a-zA-Z0-9-_.]+$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由中文字符、英文字母、数字、中划线、下划线和点组成)";
});
// 由字母、汉字、“•”
extend("pointStr", value => {
  let re = /^[\u4e00-\u9fa5_a-zA-Z_·]+$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由字母、汉字和点组成)";
});
// 输入小数(默认是小数点前八位后两位)
extend("decimalNum", (value, args) => {
  let pointS = Number(args[0]) || 7;
  let pointE = Number(args[1]) || 2;
  let reg = new RegExp(
    `^[+-]?(0|([1-9]\\d{0,${pointS}}))(\\.\\d{1,${pointE}})?$`,
    "g"
  );
  let res = reg.test(value);
  if (!res) {
    return `最多输入小数点前${pointS + 1}位和小数点后${pointE}位`;
  }
  return true;
});
// 数字限制
extend("decimalLeval", (value, args) => {
  let min = Number(args[0]);
  let max = Number(args[1]);
  try {
    let cur = Number(value);
    if (cur >= min && cur <= max) {
      return true;
    }
    return `只能输入${min}到${max}范围的值`;
  } catch (e) {
    return "请输入小数";
  }
});
// 数字限制2
extend("decimalLeval2", (value, args) => {
  let min = Number(args[0]);
  let max = Number(args[1]);
  let len = 0;
  if (value.toString().indexOf(".") >= 0) {
    len = value.split(".")[1].length;
  }
  try {
    let cur = Number(value);
    if (cur >= min && cur <= max && len <= 4) {
      return true;
    }
    return `只能输入0.0001到99999999999999.9999范围的值`;
  } catch (e) {
    return "请输入小数";
  }
});
//PT- 广告位编码
extend("adCode", value => {
  let re = /^PT\_[a-zA-Z0-9]{1,10}_[a-zA-Z0-9]{1,10}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(格式：PT_index_banner)";
});
//数字 字母 100字以内
extend("productNum", value => {
  let re = /^ZB[a-zA-Z0-9]{1,100}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}";
});
//只支持数字字母汉字
extend("productName", value => {
  let re = /^[\u4E00-\u9FA5A-Za-z0-9]+$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由数字、字母、汉字组成)";
});
extend("attrtNum", value => {
  let re = /[^\u4e00-\u9fa5]{1,100}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(100以内，数字、字母、特殊字符组成)";
});
extend("strategyName", value => {
  let re = /^[a-zA-Z][0-9a-zA-Z]{0,100}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由字母开头，数字、字母组成)";
});
//属性名称 不允许特殊字符 18位以内
///[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~！@#￥%&*（）\-+={}|《》？：“”【】、；‘’，。、]/im;
extend("accessControl", value => {
  // ^[a-zA-Z\u4e00-\u9fa5][\u4e00-\u9fa5a-zA-Z-z0-9]$
  let re = /^[a-zA-Z\u4e00-\u9fa5][\u4e00-\u9fa5a-zA-Z-z0-9]{0,49}$/;
  if (re.test(value)) {
    return true;
  }
  return "由中文、数字、字母组成,首字符不为数字";
});

//属性名称 不允许特殊字符 18位以内
///[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~！@#￥%&*（）\-+={}|《》？：“”【】、；‘’，。、]/im;
extend("attrName", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z-z0-9]+$/im;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由中文、数字、字母组成)";
});
// 联系电话  同时校验手机号和座机号
extend("telephone", value => {
  // let re = /^((0\d{2,3}-\d{7,8})|(1[3584]\d{9}))$/im;
  let re = /^[\(\)\s0-9-\+]{4,20}$/;

  if (re.test(value)) {
    return true;
  }
  return "请输入正确的联系电话";
  // return "请输入正确的{_field_}(手机或座机，如 130******** 或 010-********)";
});
extend("selectRequired", {
  ...required,
  message: "请选择{_field_}"
});
extend("productAreas", {
  ...required,
  message: "请选择地区产品"
});
extend("selectMin", (value, args) => {
  if (value.length > 0) {
    return true;
  }
  return `请至少选择${args[0]}项`;
});
//最低折扣  0-10 精确到小数点后一位 的正则  ^(\d|10)(\.\d)?$
extend("discount", value => {
  let re = /^\+?(?:\d(?:\.\d)?|10(?:\.0)?)$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入0-10之内的数字，精确到小数点后1位";
});

//最低折扣  0-10 精确到小数点后一位 的正则  ^(\d|10)(\.\d)?$
extend("setDiscount", {
  validate(value, bpdata) {
    if (value == "0" || value > "1") {
      return "请输入正确的折扣";
    }
    if (value == "" || value == null) {
      return "请输入折扣";
    }
    if (bpdata[0] == "undefined" || bpdata[0] == "") {
      bpdata[0] = 0;
    }
    if (value > 0 && value < bpdata[0]) {
      return "客户云厂商折扣不能低于伙伴最低折扣";
    }
    let re = /^\d+(\.\d{1,2})?$/;
    if (re.test(value)) {
      return true;
    }
    if (!isNaN(value) && typeof value === "number") {
      return true;
    }
    return "请输入正确的折扣";
  }
});
extend("requiredData", {
  validate(value, discount) {
    if (discount[0] == "1") {
      return;
    }
  }
});

//1-28的数字
extend("twoNum", value => {
  let re = /^[1-9]$|^[1][0-9]$|^[2][0-8]$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入1-28的数字";
});
//1-28的数字
extend("orderRule", value => {
  let re = /^[0-9a-zA-Z,]*$/g;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}格式";
});
//1-999的整数
extend("nineNum", value => {
  let re = /^\+?[1-9]{1}[0-9]{0,2}\d{0,0}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入1-999的整数";
});

//0.01-9999999.99的数字
extend("ninesNum", value => {
  // let re = /^([1-9]\d{0,3}$)|(^0\.\d{1,2}$)|(^[1-9]\d{0,3}\.\d{2})$/;
  // if (re.test(value)) {
  //   return true;
  // }
  // return "请输入0.01-9999999.99的数字";
  // var reg = /\d+(\.\d{0,2})?/

  if (value.indexOf(".") != -1) {
    let arr = value.split(".");
    if (arr[1].length > 2) {
      return "不能超过两位小数";
    }
  }
  if (value <= 9999999.99 && value >= 0.01) {
    return true;
  } else {
    return "请输入0.01-9999999.99的数字";
  }
});
// 比较时间大小
extend("after", {
  validate(value, _a) {
    var target = _a.target;
    if (!!!value || !!!target) return true;
    try {
      if (new Date(value) < new Date(target)) {
        return `{_field_}不能早于${_a.field}`;
      } else {
        return true;
      }
    } catch (error) {
      return "请输入正确的时间格式";
    }
  },
  params: [
    {
      name: "target",
      isTarget: true
    },
    {
      name: "field"
    }
  ]
});
extend("before", {
  validate(value, _a) {
    var target = _a.target;
    if (!!!value || !!!target) return true;
    try {
      if (new Date(value) > new Date(target)) {
        return `{_field_}不能晚于${_a.field}`;
      } else {
        return true;
      }
    } catch (error) {
      return "请输入正确的时间格式";
    }
  },
  params: [
    {
      name: "target",
      isTarget: true
    },
    {
      name: "field"
    }
  ]
});
extend("postattrName", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z-z0-9（\）(\)[\]<\>_{\}]+$/im;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由中文、数字、字母组成)";
});
// 拨款/回收金额 校验  ---金额不能超出余额
extend("recycleamount", {
  validate(value, args = [0.01, 0.01]) {
    let amount = args[0],
      brokerAmount = args[1];
    if (Number(value) > Number(amount)) {
      return "拨款金额不能大于可拨款额度";
    }
    if (Number(value) > Number(brokerAmount)) {
      return "拨款金额不能大于客户Broker余额";
    } else {
      return true;
    }
  }
});
extend("recoveryamount", {
  validate(value, args = [0.01]) {
    let amount = args[0];
    if (Number(value) > Number(amount)) {
      return "回收金额不能大于账户余额";
    } else {
      return true;
    }
  }
});
// 最大数字
extend("maxNum", {
  validate(value = 0, args = 0) {
    if (!value || isNaN(value)) {
      return "{_field_}格式不正确";
    }
    if (parseFloat(value) > parseFloat(args)) {
      return `{_field_}不能超过${args}`;
    }
    return true;
  }
});
// 最小数字
extend("minNum", {
  validate(value = 0, args = 0) {
    if (!value || isNaN(value)) {
      return "{_field_}格式不正确";
    }
    if (parseFloat(value) < parseFloat(args)) {
      return `{_field_}不能低于${args}`;
    }
    return true;
  }
});
// 金额 有效位数传参，默认2位
extend("money", {
  validate(value, args = [2, 0, 99999999.99]) {
    // args[0] 保留位数
    // args[1] 最小值
    // args[2] 最大值
    let digit = args[0] || 2;
    let minNum = args[1] || 0;
    let maxNum = args[2] || 99999999.99;
    if (isNaN(Number(value))) {
      return `请输入${minNum}~${maxNum}的数字`;
    }
    let re = new RegExp(
      `^(0|([1-9][0-9]*)|([0]\.[0-9]{1,2})|([1-9][0-9]*\.[0-9]{1,${digit}}))$`
    );
    if (digit == "0") {
      re = new RegExp(`^[1-9][0-9]*$`);
    }
    if (re.test(value)) {
      if (parseFloat(value) < minNum || parseFloat(value) > maxNum) {
        return `请输入${minNum}~${maxNum}的数字`;
      } else {
        return true;
      }
    } else {
      let valStr = value + "";
      if (
        valStr.indexOf(".") !== -1 &&
        valStr.slice(valStr.indexOf(".") + 1).length > digit
      ) {
        return `小数点后仅支持两位有效位数`;
      }
      return `请输入${minNum}~${maxNum}的数字`;
    }
  }
});
//数据权限包名称  4-20位，输入类型不包含除“下划线”、“中划线”、“中英文小括号/中括号”以外的特殊字符。
extend("dataName", value => {
  let re = /^[\u4e00-\u9fa5_a-zA-Z0-9-_.\\(\\)\\【\\】\\（\\）\[.*\]]+$/;
  if (re.test(value)) {
    return true;
  }
  return "由中文字符、英文字母、数字、中划线、下划线和中英文小括号/中括号组成";
});

// 最小值不能大于最大值
extend("mintomax", (value, args) => {
  if (args[0] == "" && args[1]) {
    return `请输入最小值`;
  }
  if (args[1] == "" && args[0]) {
    return `请输入最大值`;
  }
  let min = Number(args[0]);
  let max = Number(args[1]);
  if (min >= max) {
    return `最小值不能大于最大值`;
  } else {
    return true;
  }
});

// IP校验
extend("IP", value => {
  let re = /^(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])(\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)){2}(\.(1\d{2}|2[0-4]\d|25[0-4]|[1-9]\d|[1-9]))$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的IP";
});
//数据权限包名称  4-20位，输入类型不包含除“下划线”、“中划线”、“中英文小括号/中括号”以外的特殊字符。
extend("dataName", value => {
  let re = /^[\u4e00-\u9fa5_a-zA-Z0-9-_.\\(\\)\\【\\】\\（\\）\[.*\]]+$/;
  if (re.test(value)) {
    return true;
  }
  return "由中文字符、英文字母、数字、中划线、下划线和中英文小括号/中括号组成";
});
extend("phoneEmailRule", {
  ...required,
  message: "手机号/邮箱至少填一项"
});
// 由字母汉字组成{6,18}
extend("alphaChinese", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z-z]+$/im;
  if (re.test(value)) {
    return true;
  }
  return "由字母汉字组成";
});

//由数字+字母 组成 [A-Za-z][A-Za-z0-9]  字母开头
extend("appCode", value => {
  let re = /^(?!^\d+$)(?!^[a-zA-Z]+$)[0-9a-zA-Z]$/;
  // let re= /^\d{3}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(英文字母开头,由4~32位大/小写字母，数字组合)";
});

// 并发量
extend("concurrency", {
  validate(value, data) {
    if (value) {
      if (!data[0]) {
        return "请选择单位";
      }
    }
    if (value && data[0]) {
      if (value > 1000) {
        return "并发量不得大于1000";
      }
    }
    return true;
  }
});
// 并发量2
extend("concurrency2", {
  validate(value, data) {
    console.log(value, data);
    if (value) {
      if (data == "null" || !data) {
        return "请输入并发量";
      }
    }
    return true;
  }
});
//配额
extend("appQuota", value => {
  if (value > 1000) {
    return "配额不得大于1000";
  }
  return true;
});

//字母小写
extend("letters", value => {
  let re = /^[a-zA-Z][a-zA-Z_]{1,31}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入英文字母";
});

//1-100的整数（用于api管理，后带%）
extend("percentage", value => {
  let re = /^(1|([1-9]\d{0,1})|100)$/;
  //
  if (re.test(value)) {
    return true;
  }
  return "请输入1-100的整数";
});
//只支持数字字母汉字
extend("productNames", value => {
  let re = /^[\u4E00-\u9FA5A-Za-z0-9+*]+$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由*、数字、字母、汉字组成)";
});
//api管理--api名称
extend("apiNames", value => {
  let re = /^[\u4E00-\u9FA50-9a-zA-Z]{1,49}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由汉字、数字、字母组成)";
});
//api管理--转义后参数
extend("apiSerParamNames", value => {
  let re = /^[a-zA-Z]{1,32}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由英文字母组成)";
});
//api管理-参数名
extend("parameters", value => {
  let re = /^[a-zA-Z][a-zA-Z_]{1,32}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由字母开头，英文和下划线组成)";
});
//api管理-异常编码
extend("validatePhones", value => {
  let re = /^[a-zA-Z][a-zA-Z0-9]{0,50}$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由字母开头，英文和数字组成)";
});

// 只支持字母和数字
extend("LettersandNumbers", value => {
  let re = /^[A-Za-z0-9]+$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(由数字、字母组成)";
});
//由字母组成 具体限制到{args}位
extend("letterNumConfine", {
  validate(value, args) {
    let re = /^[A-Za-z]+$/;
    if (!re.test(value)) {
      return `请输入正确的{_field_}(由字母组成)`;
    }
    if (value.length != args) {
      return `只能输入${args}位字母`;
    }
    return true;
  }
});

// extend("LimitingUnderline", value => {
//   let re = /^[\u4e00-\u9fa5-a-zA-Z0-9-@\!\#\￥\%\.\&\*\（\）\…\{\}\[\]\.\,\<\>\:\;\|\"]+$/;
//   if (re.test(value)) {
//     return true;
//   }
//   return "请输入正确的{_field_}(由汉字、字母、数字、除下划线外组成)";
// });

// 匹配出下划线以外所有的字符
extend("LimitingUnderline", value => {
  let re = /_/;
  if (!re.test(value)) {
    return true;
  }
  return "请输入正确的{_field_}(不包含下划线)";
});
//输入框不为空
extend("requiredss", {
  ...required,
  message: "请输入异常内容"
});
//不能以-+=@开头
extend("customName", value => {
  let re = /^(?![-=+@])/;
  if (re.test(value)) {
    return true;
  }
  return "不能以-=+@开头";
});
//且不能是纯特殊字符、纯数字、支持汉子、英文字母
extend("regex", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z0-9]*([a-zA-Z][0-9][\u4e00-\u9fa5]|[\u4e00-\u9fa5a-zA-Z])[\u4e00-\u9fa5a-zA-Z0-9]*$/;
  if (re.test(value)) {
    return true;
  }
  return "不能输入纯数字、纯特殊字符,支持汉字、英文字母";
});
extend("backPaymentCode", value => {
  let re = /^[A-z0-9\-\.]{0,64}$/;
  if (re.test(value)) {
    return true;
  }
  return "支持0-64位数字、字母、“-”“.”";
});
//百分比
extend("percent", value => {
  let re = /^(1|([1-9]\d{0,1})|100)$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入1-100的整数";
});

// 0-32的数字
extend("percents", value => {
  let re = /^([0-9]|[1-2][0-9]|3[0-2])$/;
  if (re.test(value)) {
    return true;
  }
  return "请输入0-32的数字";
});

//机会点名称
extend("chanceName", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z0-9]{4,16}$/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}仅支持4-16位数字、字母、汉字";
});
//合同编号
extend("contractCode", value => {
  let re = /^[a-zA-Z0-9\-]{1,127}$/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}仅支持数字、字母、短连接线,最大可输入127位";
});
//合同名称
extend("contractName", value => {
  let re = /^[\u4e00-\u9fa5a-zA-Z0-9]{1,127}$/;
  if (re.test(value)) {
    return true;
  }
  return "{_field_}仅支持数字、字母、汉字，最大可输入127位";
});
你的眼睛會笑
关注
  • 4
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java使用正则表达式提取XML节点内容的方法示例
08-29
主要介绍了Java使用正则表达式提取XML节点内容的方法,结合具体实例形式分析了java针对xml格式字符串的正则匹配相关操作技巧,需要的朋友可以参考下
简单的正则表达式+js验证邮箱例子
01-01
简单的正则表达式+js验证邮箱例子 新手必备 ！
学习VUE之正则表达式全集整理
宁波阿成的博客
12-21 1030
学习VUE之正则表达式全集整理
正则表达式校验身份证号码
07-08
正则表达式验证身份证号码 共两个验证 一个是简单的 只判断是不是15位或者18位, 另外一个方法是复杂的校验,严格判断身份证号码是否合理
利用正则表达式提取固定字符之间的字符串
12-13
前言 在JS的正则零宽断言匹配中，只支持前瞻匹配，不支持后瞻。这就尴尬了，因为在业务当中，我们大多时候是知道了要目标数据的前后缀字符串，但是并不想连同前后缀一起获取。 为了模拟后瞻，我想，要不就用笨方法，先将前后缀字符串一同提取，然后再讲前后缀字符串一同replace为空字符串。于是就有了下面这个简单的方法，但确实很实用： 示例代码如下 // 提取固定字符之间的字符串 function getInnerString(source, prefix, postfix) { var regexp = new RegExp(encodeReg(prefix) + '.+' + encodeReg(
vue 最简易的邮箱正则表达式
weixin_45896119的博客
01-17 1391
直接使用的正则表达式
Vue正则表达式
qq_53237862的博客
06-28 293
【代码】Vue正则表达式。
Vue组件 正则表达式验证邮箱和手机号码
qq_45708267的博客
04-13 770
<template> <div class="addUser"> <!-- 点击添加用户对话框 --> <!-- 添加用户表单 --> <el-form :model="addUser" :rules="addUserRules" ref="addUser" label-width="70px"> <e
Vue基于Element表单校验自定义正则表达式
weixin_44523517的博客
08-19 777
Vue基于Element表单校验自定义正则表达式
vue中使用常用正则表达式
~~
12-09 2841
3~20个字符，可使用字母、数字、下划线，需以字母开头：/^[a-zA-Z]\w{2,19}$/
正则表达式去除中括号（符号）及里面包含的内容
01-19
例子：颜色:粉色[10] 尺码:S[5] 去掉[ ]及内容： preg_replace(/\[.*\]/, '', $str)1 处理后效果：颜色:粉色 尺码:S 小技巧：可把[ ]改为其他符号应用在需要的地方 ps：下面看下利用正则表达式提取括号内内容 比如现在要提取  中华人们共和国，简称（中国） 这句话中括号里的“中国” import java.util.regex.Matcher; import java.util.regex.Pattern; public class Test { public static void main(String[] args) {
正则表达式只可以输入只允许输入中文、数字、字母、下划线
08-19
正则表达式只可以输入只允许输入中文、数字、字母、下划线
Python JavaScript Vue 常用的正则表达式
01-03
正则表达式
Vue.js（自定义指令）
Luo3255069063的博客
04-18 440
【代码】Vue.js（自定义指令）
【Day 2】JavaScript、Vue
Yudiannann的博客
04-17 905
内部脚本JavaScript 代码必须位于 <script></script> 标签之间（而在 HTML 文档中，可以在，放置的 <script>，可改善显示速度通过 src 引用demo.JS 文件。
JavaScript防抖函数执行多个事件处理函数，监听浏览器窗口拖拽事件（Vue防抖函数执行多个事件处理函数）
weixin_65793170的博客
04-17 400
当用户调整浏览器窗口大小时，浏览器会触发 resize 事件。通常，我们希望在窗口大小改变时执行一些操作，但是如果用户频繁调整窗口大小，可能会导致这些操作被频繁触发，影响页面性能和用户体验。
vue 实现级联选择器功能
最新发布
清音的博客
04-22 422
数组包含了级联选择器的数据源，其中每个对象表示一个选项，包括。组件来实现级联选择器功能,下面是一个示例代码，演示如何使用。组件初始化级联选择器，并设置默认值为单位。对象用于指定数据结构中的属性名，以便。上，可以在初始化时选中指定的值。使用 Element UI 的。中设置初始选中值为单位。组件正确地解析数据。
4. Vue Router4 动态路由
一名全栈开发工程师
04-17 517
在 Vue Router 4 中，动态路由是一种非常强大的功能，它允许我们根据不同的 URL 参数来渲染不同的组件或者同一组件的不同状态。这对于创建用户个人页面或者具有大量内容的应用来说非常有用。
Vue的基础语法（初学Vue）
百赢出品，必属精品
04-17 1026
Vue.js（通常简称为 Vue）是一款流行的开源 JavaScript 前端框架，用于构建交互式的用户界面和单页面应用程序（SPA）。Vue 的设计灵感主要来自于 Angular 和 React，但它的核心库更小巧，易于上手，并且具有更快的渲染速度。
vue 正则表达式 /
11-30
以下是关于Vue正则表达式的介绍： Vue.js是一个流行的JavaScript框架，它允许您使用正则表达式来验证表单输入。在Vue.js中，您可以使用v-model指令将表单输入绑定到Vue实例中的数据属性。然后，您可以使用正则表达式来验证这些数据属性。 以下是一个使用Vue.js和正则表达式验证电子邮件地址的示例： ```html <template> <div> <label for="email">Email:</label> <input type="text" id="email" v-model="email"> <span v-if="!validEmail">Please enter a valid email address</span> </div> </template> <script> export default { data() { return { email: '', emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ } }, computed: { validEmail() { return this.emailRegex.test(this.email) } } } </script> ``` 在上面的示例中，我们使用了一个名为emailRegex的正则表达式来验证电子邮件地址。我们还定义了一个名为validEmail的计算属性，该属性使用test()方法来测试email属性是否与emailRegex匹配。如果匹配，则validEmail为true，否则为false。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值