JavaScript正则表达式

  • 2019-06-15
  • 191
  • 0
  • 0

一、认识正则表达式

  1. 正则表达式是描述字符模式的对象,正则表达式用于对字符串模式匹配及检索替换,是对字符串执行模式匹配的强大工具。
  2. StringRegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。
  3. 正则表达式主要用来验证客户端的输入数据。可以节约大量的服务器端的系统资源,并且提供更好的用户体验。

二、创建正则表达式

  1. 字面量。语法:Reg = /pattern/modifiers; 字面量的正则由两个正斜杆组成//,第一个正斜杆后面写规则:/pattern[规则可以写各式各样的元字符|量词|字集|断言…]。第二个正斜杆后面写标识符/modifiers[g全局匹配 | i忽略大小写 | m换行匹配 | ^起始位置 | $结束位置] 标识符。
var Reg = /box/gi;
  1. 构造函数。语法 Reg = new RegExp( pattern , modifiers ); pattern ,modifiers此时是字符串。何种方法创建都是一样的,pattern 模式 模板,要匹配的内容,modifiers 修饰符。
var Reg = new RegExp("box","gi");

三、正则表达式用法及区别

  1. String中正则表达式方法。
方法 描述
String.match(Reg) 返回RegExp匹配的包含全部字符串的数组或null
String.search(Reg) 返回RegExp匹配字符串首次出现的位置
String.replace(Reg, newStr) 用newStr替换RegExp匹配结果,并返回新字符串
String.split(Reg) 返回字符串按指定RegExp拆分的数组
var str = 'a1b2c3a4a5',
    reg = /a/g;
console.log(str.match(reg)); //["a", "a", "a"]

var str = 'a1b2c3a4a5',
    reg = /a/;
console.log(str.search(reg)); //0

var str = 'a1b2c3a4a5',
    reg = /a/g;
console.log(str.replace(reg,function(){
    console.log(arguments);
    return 5555;
}));

var str = 'a,b,c,d',
    reg = /,/g;
//console.log(str.split(',')); //["a", "b", "c", "d"]
console.log(str.split(reg)) //["a", "b", "c", "d"]
  1. RegExp对象的方法
方法 描述
RegExp.exec(String) 在字符串中执行匹配搜索,返回首次匹配结果数组
RegExp.test(String) 在字符串中测试模式匹配,返回true或false
var str = 'abcd',
    reg = /\w/g;
console.log(reg.exec(str)); //["a", index: 0, input: "abcd", groups: undefined]
console.log(reg.exec(str)); //["b", index: 1, input: "abcd", groups: undefined]
console.log(reg.exec(str)); //["c", index: 2, input: "abcd", groups: undefined]
console.log(reg.exec(str)); //["d", index: 3, input: "abcd", groups: undefined]
console.log(reg.exec(str)); //null
console.log(reg.exec(str)); //["a", index: 0, input: "abcd", groups: undefined]

var str = 'abcd',
    reg = /7/g;
console.log(reg.test(str)); //false

四、修饰符

  1. 修饰符也称作标识符,可指定匹配的模式,修饰符用于执行区分大小写和全局匹配。
  2. i忽略大小写匹配。
  3. g全局匹配,没有g只匹配第一个元素,就不在进行匹配。
  4. m执行多行匹配。
var patt =  /pattern/i;         //忽略大小写匹配
var patt =  /pattern/g;         //全局匹配
var patt =  /pattern/m;         //执行多行匹配

五、元字符

  1. 在正则表达式中具有特殊意义的专用字符。
  2. 特殊的转译字符. \ /
. 单个任意字符,除了换行符\n与制表符\r 
\ 转义字符,将具有特殊意义的符号转义成普通符号: \.
\d 数字[0~9]
\D 非数字
\s 空格
\S 非空格
\w 字符[字母|数字|下划线]
\W 非字符
\b 单词边界( 除了 (字)字母 数字_ 都算单词边界) 
\B 非单词边界
var reg = /\./;//匹配.
var reg = /\\/;//匹配\
var reg = /\//;//匹配/

var str = '\\';
var reg = /\\/g;
console.log(reg.test(str)); //true

六、量词

  1. 匹配字符的出现次数,匹配模式中有贪婪模式与懒惰模式。
  2. 量词 默认就是贪婪模式。
n? 可有可无,匹配0个或1个n的字符串  
n* 匹配0个或多个字符串(任意个) 
n+ 匹配至少1个n字符串 
n{num} 匹配包含num个n的序列的字符串
n{min,max} 匹配包含至少min或至多max个n的序列的字符串
n{num,} 匹配至少num个n的序列字符串

七、 特殊符号

^n 匹配以n开头的字符串 
n$ 匹配以n结尾的字符串
[^n] ^出现中在[]中括号里表示取不包含n字符的字符串 
n|m 匹配n或者m.两个只取一个

八、贪婪/懒惰

贪婪: 尽可能多的匹配 / 惰性: 尽可能少的匹配。

n+ 贪婪模式为默认 
n+? 量词后面带?问号就是懒惰模式,以次类推
{n,m} 贪婪模式 
{n,m}? 懒惰模式
var reg = /好{3}/;//查找出现3次的字符
var reg = /好{0,9}/;//匹配一个字符出现9次的,不行的话就递减 9 8 7 6 5 4 3 2 1 0(贪婪模式)
var reg = /好{1,9}/;//匹配一个字符出现1~9次的 先最大次数开始匹配(贪婪模式)
var reg = /好{1,}/;//最少出现一次,最多没有上限
var reg = /好{1,2}/;//最少出现一次,最多两次
var reg = /好*/;// 匹配0个或任意个字符串(任意个) {0,}
var reg = /好+/;//只是一个最多没有上限{1,}
var reg = /好?/;//可有可无 可以是没有也可以是1个 {0,1}

var reg = /好{3,9}/;//贪婪模式 往多的找
var reg = /好{2,9}?/;//惰性(懒惰)模式 往少的找
var reg = /好{2,9}?/g;//全局匹配

var reg = /^l\w+/gm;//查找l开头的任意字符
var reg = /\w+2$/gm;//任意字符后面是以2结束的字符

九、字集[]/分组()

  1. 字集[],[]代表一个集合。
[1-9] 匹配0~9之间的字符  
[^1-9] 匹配非0~9之间的字符 
[a-z] 匹配小写a至小写z的字符 
[A-Z] 匹配大写A至大写Z的字符 
[\u4e00-\u9fa5] 匹配所有中文 
[1-9a-zA-Z] 可配合使用 
  1. 分组(),()代表一个分组。
(abc)b 匹配到abcd字符串abc是一个不可划分的整体
(\d{4})b 匹配任意4个数字加上b的字符 

匹配到的分组可以依次使用 $1 $2 $3取到。

var y = "2018-06-29";
y.replace(/(d+)-(d+)-(d+)/,"$2/$3/$1");//"06/29/2018"
var str = 'abcdefg';
var reg = /(abc)d/;//匹配abcd
var val = reg.exec( str);
console.log( val );   //["abcd", "abc", index: 0, input: "abcdefg"]
//索引0 为匹配的结果,索引1 为第一个子表达式 匹配结果 ,index :首次匹配成功的索引值, input: 匹配目标。

(pattern)匹配pattern并捕获结果,自动设置组号,是从1开始的正整数,通过\num进行引用,引用是值的引用,匹配结果的引用不是匹配形式引用。

十、断言/前瞻

  1. 正则表达式中,用于查找某些内容之前(前瞻)或者之后(后顾)的东西,叫做断言。JavaScript只有前瞻,并没有后顾。
  2. 零宽度,说明它是不占字符宽度的,只是一个位置,它不匹配任何东西。(?=pattern) 零宽正向断言 ,(?!pattern) 零宽负向断言。
//匹配 “Windows2000” 中的 “Windows” ,不匹配 “Windows3.1” 中的 “Windows”。
Windows(?=2000) //匹配windows且后面跟2000
//匹配 “Windows3.1” 中的 “Windows” ,不匹配 “Windows2000” 中的 “Windows”。
Windows (?!2000)//匹配windows且后面非2000

评论

还没有任何评论,你来说两句吧