正则笔记-基础语法，测试案例，常用规则等

꧁꫞꯭伟꯭伟꯭꫞꧂

已于 2022-08-08 11:25:25 修改

阅读量420

点赞数

分类专栏： javaScript 文章标签： javascript

于 2020-12-11 15:55:19 首次发布

本文链接：https://blog.csdn.net/Anonymous996/article/details/111035193

版权

javaScript 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

RegExp-正则表达式

正则表达式主要分两种

字面量创建： let reg = /abcd/
内置构造函数： let reg = new RegExp('abcd‘’)；

匹配 => reg.test(str) 返回值 布尔
捕获 => reg.exec(str) 返回值 null 或者 数组。

基本元字符

元字符
  \s => 表示只匹配一个空格 const reg = /\s/
  \S => 表示一个非空格 const reg = /\S/
  \t => 表示需要一个制表符(tab) const reg = /\t/
  \d => 表示一个数字(0-9) const reg = /\d/ 
  \D => 表示非数字字符 const reg = /\D/
  \w => 表示包含一个数字字母下划线三选一 const /\w/
  \W => 表示一个 除开数字 字母 下划线的字符之外的字符 const reg = /\W/
  . => 表示有一个非换行任意字符(\n换行) const reg = /./ 例子 reg.test('\n')
  \ => 转义符 把有意义内容转为没意义的内容 const reg = /./ 非换行 const reg = /\./ 匹配一个.文本 const reg = /\\/ 匹配一个\ 字符串中\也需要转义

边界操作符

边界元字符
  ^ 以什么开头 const reg = /^\d/ 以数字开头
  $ 以什么结束 const reg = /\d$/ 以数字结尾

限定元字符
   	+ 写在普通元字符或者字母符号后面
    + 修饰前面《一个符号》的出现次数{内不能有空格}

    * 出现0 ~ 多次 const reg = /\d*/ 表示 0 到多个数字
    + 表示 1 ~ 多次 const reg = /^\d+$/ 数字开头，至少包含资格数字且数字结尾
    ? 表示 0 ~ 1次 const reg = /^\d?$/ 只能有0 或者1 次数字
    {n} 表示文本只能是三个数字组成 const reg = /^\d{3}$/
    {n,} 表示数字只能从2到多个开始 const reg = /^\d{2,}/ 
    {n,m} 表示数字只能是2~4个组成 const reg = /^\d{2,4}$/

      {0,} 等价于 * {1,} 等价于 +
      {0,1} 等价于 ？
      [0-9A-ZA-Z_] 等价于\w
	  [^0-9a-zA-Z_] 等价于 \W
	  [0-9] 等价于 \d
	  [^0-9] 等价于\s
	  [ ] \s
	  [^ ] 等价于\S

贪婪匹配

    / * 贪婪
      + 当给你一个符号使用限定符的时候
      + 在你捕获的时候， 他会尽可能'多'的去捕获内容
      + 我们管这个特性叫做正则的贪婪性
      const reg = /\d+/ reg.exec('abc123456789abc) 取值为123456789

    / * 非贪婪
      + 正则在捕获的时候尽可能多的按照最小值来捕获
      + 写限定符的时候， 在后面多加一个？
      const reg = /\d+?/ reg.exec('abc123456789abc) 取值为1

      const reg = /\d*?/ reg.exec('123456789abc) 取值为123456789
      ? 操作符
      const reg = /\d?/ reg.exec(123456789) 取值为 1
      const reg = /\d??/ reg.exec('123456789abc)  取值为 ""
      const reg = /<.+?>/ reg.exec("<div class="z" style="ss"><span></span></div>") 取值为 <div class="z" style="ss">

特殊元字符

() 表示整体
	    单独捕获一个字符串的时候
	    从左边开始每个小括号一次是数组里面的[1]开始内容
	    动左到右次数小括号的开始括号
  const reg = /abcd{2}/; reg.test('abcdd)
  const reg = /(abcd){2}/ reg.test('abcdabcd')
  /单独捕获
  const reg = /\d+(\s+)\d+/ reg.exec('123  123')  index1 \n\n

  const reg = /(\d+(\s+))\d+/ reg.exec('123  123') index1 123\n\n index2 \n\n
  (?:) 匹配但不捕获
  const reg = /\d+(?:\s+\d+)/
  | 占位或 大部分和（）一起用
  const reg = /(abc|def)/ ref.test('abc')
  [] 任意字符条件
  const reg = /[abcd]/ reg.test('sqwertd)
  [^] 非里面任意一个字符都行
  const reg = /[^abcd]/ reg.test('e')
  const reg = /^[0-9]$/
  - 连码 1~9任意一个字符 [^0-9][^z-z][^A-Z]
  当(.)出现在[] 或者[^]里面时 就表示文本
  const reg = /^(abc|def){2}$/ reg.test('defabc') 表示任意整体，出现两次。

练习

  验证字符串 只能有数字字母下划线组成， 6-12位 不能以_开头
  const reg = /^[a-z0-9A-Z]\w{5,11}$/
  验证数字范围 0 ~ 255
  => 一位数           \d          0-9
  => 两位数           \d{2}       10-99
  => 1 开头的三位数   1\d{2}      100-199
  => 2 开头 0 ~ 4     2[0-4]\d    200-249
  => 2 开头 5 三位数  25[0-5]     250-255
    reg = /^(\d|\d{2}|1\d{2}|2[0-4]\d|25[0-5])$/
    reg = /^(1?\d{1,2}|2[0-4]\d|25[0-5])$/
    校验数字 30-365之间
    const reg = /^([3-9][1-9]|[4-9]\d|[1-2]\d{2}|3[0-5]\d|36[0-5]|365)$/
	控制台测试：
	for(let i = 0; i <= 366; i++ ){
	    if (/^([4-9][1-9]|[5-9]\d|[1-2]\d{2}|3[0-5]\d|36[0-5]|365)$/.test(i)) {
	        console.log(i, true)
	    } else {console.log(i, false)}
	}

在这里插入图片描述

/**
 * 验证电子邮箱格式
 */
function email(value) {
	return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(value);
}

/**
 * 验证手机格式
 */
function mobile(value) {
	return /^1[3-9]\d{9}$/.test(value)
}

/**
 * 验证URL格式
 */
function url(value) {
	return /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w-.\/?%&=]*)?/.test(value)
}

/**
 * 验证日期格式
 */
function date(value) {
	return !/Invalid|NaN/.test(new Date(value).toString())
}

/**
 * 验证ISO类型的日期格式
 */
function dateISO(value) {
	return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value)
}

/**
 * 验证十进制数字
 */
function number(value) {
	return /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value)
}

/**
 * 验证整数
 */
function digits(value) {
	return /^\d+$/.test(value)
}

/**
 * 验证身份证号码
 */
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)
}

/**
 * 是否车牌号
 */
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位小数
 */
function amount(value) {
	//金额，只允许保留两位小数
	return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value);
}

/**
 * 中文
 */
function chinese(value) {
	let reg = /^[\u4e00-\u9fa5]+$/gi;
	return reg.test(value);
}

/**
 * 只能输入字母
 */
function letter(value) {
	return /^[a-zA-Z]*$/.test(value);
}

/**
 * 只能是字母或者数字
 */
function enOrNum(value) {
	//英文或者数字
	let reg = /^[0-9a-zA-Z]*$/g;
	return reg.test(value);
}

/**
 * 验证是否包含某个值
 */
function contains(value, param) {
	return value.indexOf(param) >= 0
}

/**
 * 验证一个值范围[min, max]
 */
function range(value, param) {
	return value >= param[0] && value <= param[1]
}

/**
 * 验证一个长度范围[min, max]
 */
function rangeLength(value, param) {
	return value.length >= param[0] && value.length <= param[1]
}

/**
 * 是否固定电话
 */
function landline(value) {
	let reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/;
	return reg.test(value);
}

/**
 * 判断是否为空
 */
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;
}

/**
 * 是否json字符串
 */
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;
}


/**
 * 是否数组
 */
function array(value) {
	if (typeof Array.isArray === "function") {
		return Array.isArray(value);
	} else {
		return Object.prototype.toString.call(value) === "[object Array]";
	}
}

/**
 * 是否对象
 */
function object(value) {
	return Object.prototype.toString.call(value) === '[object Object]';
}

/**
 * 是否短信验证码
 */
function code(value, len = 6) {
	return new RegExp(`^\\d{${len}}$`).test(value);
}

꧁꫞꯭伟꯭伟꯭꫞꧂

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
正则笔记-基础语法，测试案例，常用规则等

RegExp-正则表达式正则表达式主要分两种字面量创建： let reg = /abcd/内置构造函数： let reg = new RegExp('abcd‘’)；匹配 => reg.test(str) 返回值布尔捕获 => reg.exec(str) 返回值 null 或者数组。基本元字符标记文本元字符 \s => 表示只匹配一个空格 const reg = /\s/ \S => 表示一个非空格 const reg = /\S/ \t =>
复制链接

扫一扫

专栏目录