type 类型判断

发表于 更新于 分类于

判断字符串是否符合某种类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
function checkStr(str, type) {
  switch (type) {
    // 手机号码
    case "phone":
      return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);
    // 座机
    case "tel":
      return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
    // 身份证
    case "card":
      return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);
    // 密码以字母开头，长度在6~18之间，只能包含字母、数字和下划线
    case "pwd":
      return /^[a-zA-Z]\w{5,17}$/.test(str);
    // 邮政编码
    case "postal":
      return /[1-9]\d{5}(?!\d)/.test(str);
    // QQ号
    case "QQ":
      return /^[1-9][0-9]{4,9}$/.test(str);
    // 邮箱
    case "email":
      return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
    // 金额(小数点2位)
    case "money":
      return /^\d*(?:\.\d{0,2})?$/.test(str);
    // 网址
    case "URL":
      return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str);
    // IP
    case "IP":
      return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);
    // 日期时间
    case "date":
      return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str);
    // 数字
    case "number":
      return /^[0-9]$/.test(str);
    // 英文
    case "english":
      return /^[a-zA-Z]+$/.test(str);
    // 中文
    case "chinese":
      return /^[\u4E00-\u9FA5]+$/.test(str);
    // 小写
    case "lower":
      return /^[a-z]+$/.test(str);
    // 大写
    case "upper":
      return /^[A-Z]+$/.test(str);
    // HTML标记
    case "HTML":
      return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
    default:
      return true;
  }
}

是否电子邮箱格式

1
2
3
function email(value) {
  return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(value);
}

是否手机格式

1
2
3
function mobile(value) {
  return /^1[3-9]\d{9}$/.test(value);
}

是否 URL 格式

1
2
3
export const url = (v) => /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w-.\/?%&=]*)?/.test(v);

export const url = (v) => /(http|https):\/\/([\w.]+\/?)\S*/.test(v);

是否解析 url 参数

1
export const parseUrl = (v) => /([^?=&]+)=([^?=&]+)/g.test(v);

是否 MAC 地址正则

1
export const mac = (v) => /^([0-9a-fA-F]{2})(([/\s:-][0-9a-fA-F]{2}){5})$/.test(v);

是否日期格式

1
2
3
function date(value) {
  return !/Invalid|NaN/.test(new Date(value).toString());
}

是否 ISO 类型的日期格式

1
2
3
function dateISO(value) {
  return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value);
}

是否整数

1
export const digits = (v) => /^\d+$/.test(v);

是否整数–带负数

1
export const integer = (v) => /^-?[1-9]\d+$/.test(v);

是否身份证号码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
function idCard(value) {
  return /^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/.test(value);
}

export const idCard = (v) => /^d{6}(18|19|20)?d{2}(0[1-9]|1[12])(0[1-9]|[12]d|3[01])d{3}(d|X)$/i.test(v);

// 严格的身份校验
function idCard(sId) {
  if (!/(^\d{15}$)|(^\d{17}(\d|X|x)$)/.test(sId)) {
    alert("你输入的身份证长度或格式错误");
    return false;
  }
  //身份证城市
  var aCity = {
    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 (!aCity[parseInt(sId.substr(0, 2))]) {
    alert("你的身份证地区非法");
    return false;
  }

  // 出生日期验证
  var sBirthday = (sId.substr(6, 4) + "-" + Number(sId.substr(10, 2)) + "-" + Number(sId.substr(12, 2))).replace(/-/g, "/"),
    d = new Date(sBirthday);
  if (sBirthday != d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate()) {
    alert("身份证上的出生日期非法");
    return false;
  }

  // 身份证号码校验
  var sum = 0,
    weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2],
    codes = "10X98765432";
  for (var i = 0; i < sId.length - 1; i++) {
    sum += sId[i] * weights[i];
  }
  var last = codes[sum % 11]; //计算出来的最后一位身份证号码
  if (sId[sId.length - 1] != last) {
    alert("你输入的身份证号非法");
    return false;
  }

  return true;
}

是否车牌号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
export const carNo = (v) =>
  /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4,5}[A-Z0-9挂学警港澳]{1}$/.test(v);

export function carNo(value) {
  // 新能源车牌
  const xreg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
  // 旧车牌
  const creg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
  if (value.length === 7) {
    return creg.test(value);
  } else if (value.length === 8) {
    return xreg.test(value);
  } else {
    return false;
  }
}

是否金额，只允许 2 位小数

1
export const amount = (v) => /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(v);

是否中文

1
export const chinese = (v) => /^[\u4e00-\u9fa5]+$/gi.test(v);

是否 json 字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function jsonString(value) {
  if (typeof value == "string") {
    try {
      var obj = JSON.parse(value);
      if (typeof obj == "object" && obj) {
        return true;
      } else {
        return false;
      }
    } catch (e) {
      return false;
    }
  }
  return false;
}

判断是否为空

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
function empty(value) {
  switch (typeof value) {
    case "undefined":
      return true;
    case "string":
      if (value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, "").length == 0) return true;
      break;
    case "boolean":
      if (!value) return true;
      break;
    case "number":
      if (0 === value || isNaN(value)) return true;
      break;
    case "object":
      if (null === value || value.length === 0) return true;
      for (var i in value) {
        return false;
      }
      return true;
  }
  return false;
}

export function empty(val) {
  const type = typeof val;
  const ptype = Object.prototype.toString.call(val);
  if (ptype === "[object Undefined]") {
    return true;
  } else if (ptype === "[object String]" || ptype === "[object Array]") {
    //字条串或数组
    return val.length === 0;
  } else if (ptype === "[object Object]") {
    return JSON.stringify(val) == "{}";
  } else if (type == "number") {
    //Number 型
    return isNaN(val);
  } else if (type == "boolean") {
    return false;
  } else {
    return true;
  }
}

是否固定电话

1
2
3
4
function landline(value) {
  let reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/;
  return reg.test(value);
}

如果 value 小于 min，取 min；如果 value 大于 max，取 max

1
2
3
4
5
6
7
/**
 * 如果value小于min，取min；如果value大于max，取max
 * @param {number} min
 * @param {number} max
 * @param {number} value
 */
export const getRangeV = (min = 0, max = 0, value = 0) => Math.max(min, Math.min(max, Number(value)));

验证一个值的范围[min, max]

1
export const range = (v, p) => v >= p[0] && v <= p[1];

验证一个长度的范围[min, max]

1
export const rangeLength = (v, p) => v.length >= p[0] && v.length <= p[1];

是否包含某个值

1
export const contains = (value, param) => value.indexOf(param) >= 0;

是否是纯空格

1
export const space = (v) => v.replace(/[, ]/g, "") === "";

是否字符串

1
2
3
export const string = (v) => typeof v === "string";

export const string = (v) => Object.prototype.toString.call(v).slice(8, -1) === "String";

是否字母

1
export const letter = (v) => /^[a-zA-Z]*$/.test(v);

是否数字

1
2
3
4
5
6
7
8
9
10
11
12
export const number = (v) => Object.prototype.toString.call(v).slice(8, -1) === "Number";

export const number = (v) => /^[+-]?(\d+\.?\d*|\.\d+|\d\.\d+e\+\d+)$/.test(v);

export function number(value) {
  if (isNaN(value)) {
    return false;
  }

  // 修改源码，将字符串数值先转为数值
  return typeof +value === "number";
}

是否字母或者数字

1
export const enOrNum = (v) => /^[0-9a-zA-Z]*$/g.test(v);

是否 boolean

1
export const boolean = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Boolean";

是否函数

1
export const func = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Function";

是否为 null

1
export const isNull = (v) => Object.prototype.toString.call(o).slice(8, -1) === "Null";

是否 undefined

1
export const isUndefined = (v) => Object.prototype.toString.call(o).slice(8, -1) === "Undefined";

是否对象

1
2
3
export const object = (v) => Object.prototype.toString.call(v) === "[object Object]";

export const object = (v) => Object.prototype.toString.call(v).slice(8, -1) === "Object";

是否数组

1
export const array = (v) => Object.prototype.toString.call(v).slice(8, -1) === "Array";
1
2
3
4
5
6
7
function array(v) {
  if (typeof Array.isArray === "function") {
    return Array.isArray(v);
  } else {
    return Object.prototype.toString.call(v) === "[object Array]";
  }
}

是否时间

1
export const isDate = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Date";

是否短信验证码

1
export const code = (value, len = 6) => new RegExp(`^\\d{${len}}$`).test(value);

是否正则

1
export const regExp = (o) => Object.prototype.toString.call(o).slice(8, -1) === "RegExp";

是否错误对象

1
export const error = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Error";

是否 Symbol 函数

1
export const symbol = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Symbol";

是否 Promise 对象

1
export const promise = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Promise";

是否 Set 对象

1
export const isSet = (o) => Object.prototype.toString.call(o).slice(8, -1) === "Set";

是否 true 或 false

1
2
3
4
5
6
7
8
9
10
11
export const isFalse = (o) =>
   (!o || o === "null" || o === "undefined" || o === "false" || o === "NaN") {
    return true
  } else {
    return false;
  }
}

export const isTrue = (o) =>
   !this.isFalse(o);

是否 emoji

1
2
3
4
export function emoji(str) {
  var reg = /[^\u0020-\u007E\u00A0-\u00BE\u2E80-\uA4CF\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFFEF\u0080-\u009F\u2000-\u201f\u2026\u2022\u20ac\r\n]/g;
  return reg.test(str);
}

是否图片格式

1
2
3
4
5
export function image(value) {
  const newValue = (value || "").split("?")[0];
  const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i;
  return IMAGE_REGEXP.test(newValue);
}

是否视频格式

1
2
3
4
export function video(value) {
  const VIDEO_REGEXP = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv|m3u8)/i;
  return VIDEO_REGEXP.test(value);
}

判断是否包含特殊字符串

1
2
3
4
5
6
7
8
export function RegExpString(str) {
  var p = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）——|{}【】‘；：”“'。，、？]");
  if (p.test(str)) {
    return true;
  } else {
    return false;
  }
}

判断密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 密码8-32位
export const password = (v) => /^[0-9A-Za-z]{8,32}$/.test(v);
// 密码8-20位，至少包含数字、大写和小写字母中的两种
export const password = (v) => /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[^]{8,20}$/.test(v);
// 密码强度
export const pwdStrength = (v) => {
  let level = 0;
  if (v) {
    /[0-9]/.test(v) && level++; // 判断这个字符串中有没有数字
    /[a-zA-Z]/.test(v) && level++; // 判断字符串中有没有字母
    /[^0-9a-zA-Z_]/.test(v) && level++; // 判断字符串中有没有特殊符号
  }
  return level;
};

校验图片格式

1
2
3
4
5
export function verifySuffix(fileName, imageFormat) {
  let suffix = `(${imageFormat})`;
  var regular = new RegExp(`.*.${suffix}`);
  return regular.test(fileName);
}

是否 iOS

1
export const isIos = () => navigator.userAgent.indexOf("iPhone") > -1;

是否 PC

1
2
3
4
5
6
7
8
9
10
11
12
function isPC() {
  var userAgentInfo = navigator.userAgent;
  var Agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
  var flag = true;
  for (var v = 0; v < Agents.length; v++) {
    if (userAgentInfo.indexOf(Agents[v]) > 0) {
      flag = false;
      break;
    }
  }
  return flag;
}

浏览器类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function browserType() {
  var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串
  var isOpera = userAgent.indexOf("Opera") > -1; //判断是否Opera浏览器
  var isIE = userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1 && !isOpera; //判断是否IE浏览器
  var isIE11 = userAgent.indexOf("Trident") > -1 && userAgent.indexOf("rv:11.0") > -1;
  var isEdge = userAgent.indexOf("Edge") > -1 && !isIE; //判断是否IE的Edge浏览器
  var isFF = userAgent.indexOf("Firefox") > -1; //判断是否Firefox浏览器
  var isSafari = userAgent.indexOf("Safari") > -1 && userAgent.indexOf("Chrome") == -1; //判断是否Safari浏览器
  var isChrome = userAgent.indexOf("Chrome") > -1 && userAgent.indexOf("Safari") > -1; //判断Chrome浏览器

  if (isIE) {
    var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
    reIE.test(userAgent);
    var fIEVersion = parseFloat(RegExp["$1"]);
    if (fIEVersion == 7) return "IE7";
    else if (fIEVersion == 8) return "IE8";
    else if (fIEVersion == 9) return "IE9";
    else if (fIEVersion == 10) return "IE10";
    else return "IE7以下"; //IE版本过低
  }
  if (isIE11) return "IE11";
  if (isEdge) return "Edge";
  if (isFF) return "FF";
  if (isOpera) return "Opera";
  if (isSafari) return "Safari";
  if (isChrome) return "Chrome";
}