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位";
});