正则表达式都是操作字符串的
作用:对数据进行查找、替换、有效性验证
创建正则表达式的两种方式:
//字面量方式
/js/
//构造函数方式
regular expressionnew RegExp()
普通字符:字母 数字 汉字 _ 空格 ; , @ (没有特殊含义的符号)
两种匹配的方式:
test 测试,找到返回true,反之为false
exec 匹配字符,找到的话就返回该字符(以数组形式),反之返回null
这两个都是属于正则的方法,所以前面是跟的正则
var str="i love js";var pattern=/js/;
console.log(pattern.test(str));//true
console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]
var pattern=/Js/;
console.log(pattern.test(str));//false
console.log(pattern.exec(str));//null
正则默认情况下是区分大小写的
使用模式修饰符可以设置不区分大小写
三种模式修饰符:
i ignoreCase 忽略大小写
g global 全局匹配
m multiline 多行匹配
var str="i love js";var pattern=/Js/i;
console.log(pattern.test(str));//true
console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]
i g m这三个模式修饰符可以任意组合,无顺序要求
var str="i love js";var pattern=new RegExp("js");
console.log(pattern.test(str));//true
console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]
var pattern=new RegExp("Js");
console.log(pattern.test(str));//false
console.log(pattern.exec(str));//null
var pattern=new RegExp("Js","i");
console.log(pattern.test(str));//true
console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]
字面量方式与构造函数方式的区别:
/js/i 直观简洁
new RegExp("js", "i") 可以由于变量的检测
var str="i love js";var userInput="js";//需要匹配的字符在变量中
var pattern=/userInput/i;//该方式不可取,直接匹配的是userInput
console.log(pattern.test(str));//false
console.log(pattern.exec(str));//null
var userInput="js";//需要匹配的字符在变量中
var pattern="/"+userInput+"/i";//该方式不可取,正则变为了字符串,不再具有test和exec方法
console.log(typeof pattern);//string
console.log(pattern.test(str));//报错
console.log(pattern.exec(str));//报错
var pattern=new RegExp(userInput,"i");
console.log(typeof pattern);//object 正则属于正则对象
console.log(pattern.test(str));//true
console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]
简单的转义字符
/ 表示正则的边界,匹配时需要进行转义
var str="//我是注释";var pattern=;
console.log(pattern.exec(str));//["//", index: 0, input: "//我是注释", groups: undefined]
字符串中如果存在 ,默认会对下一个字符进行转义,如果需要作为普通字符处理,就对转义字符 再进行转义处理 \
var str="\\";
console.log(str);//结果只显示\
普通字符加上 可能会有特殊含义
如 n 代表换行
var str="nba";var pattern=/n/;
console.log(pattern.exec(str));//匹配n ["n", index: 0, input: "nba", groups: undefined]
var pattern2=/n/;
console.log(pattern2.exec(str));//匹配换行符 null
t 匹配 tab键
var str=" hello";var pattern=/t/;
console.log(pattern.exec(str));//匹配n [" ", index: 0, input: " hello", groups: undefined]
可以用 ascii码 来正则匹配字符
var str="helloncyy";var pattern=/x0A/;
console.log(pattern.exec(str));//匹配n ["↵", index: 5, input: "hello↵cyy", groups: undefined]
可以用 unicode 编码来正则匹配字符
var str=" 前面是tab键";var pattern=/u0009/;
console.log(pattern.exec(str));//匹配tab键 [" ", index: 0, input: " 前面是tab键", groups: undefined]
unicode 常用于匹配汉字
匹配一个字符串中的所有中文:u4e00-u9fa5
var str="i am 陈莺莺";var pattern=/[u4e00-u9fa5]/;
console.log(pattern.exec(str));//匹配中文 ["陈", index: 5, input: "i am 陈莺莺", groups: undefined]
可以匹配换行符的有: n x0A u000A
字符类
[ ] 匹配中间的任意一个字符
var str="javascript";var pattern=/[js]/;
console.log(pattern.exec(str));//匹配j ["j", index: 0, input: "javascript", groups: undefined]
[^ ] 表示取反
var str="javascript";var pattern=/[^js]/;//匹配除了j和s之外的
console.log(pattern.exec(str));//["a", index: 1, input: "javascript", groups: undefined]
[ ] 中间可以是一个范围
var str="javascript";var pattern=/[k-z]/;//匹配k-z之间的字母
console.log(pattern.exec(str));//["v", index: 2, input: "javascript", groups: undefined]
表示范围时,前面的必须小于等于后面的
var str="javascript";var pattern=/[c-c]/;//前面等于后面
console.log(pattern.exec(str));//["c", index: 5, input: "javascript", groups: undefined]
var pattern2=/[c-b]/;//前面大于后面
console.log(pattern2.exec(str));//报错
同时匹配大小写字母
var str="JavaScript";var pattern=/[a-zA-Z]/;//前面等于后面
console.log(pattern.exec(str));//["J", index: 0, input: "JavaScript", groups: undefined]
匹配所有数字 0-9
var str="JavaScript3333";var pattern=/[0-9]/;
console.log(pattern.exec(str));//["3", index: 10, input: "JavaScript3333", groups: undefined]
[ ] 中间可任意组合,如
[a-zA-Z0-9@_]
常用的字符类:
. 匹配所有除了 n 之外的字符
var str="3.14";var pattern=/./;
console.log(pattern.exec(str));//["3", index: 0, input: "3.14", groups: undefined]
如果单纯匹配 . 转义即可
var str="3.14";var pattern=/./;
console.log(pattern.exec(str));//[".", index: 1, input: "3.14", groups: undefined]
. 不能匹配换行符
var str="n";var pattern=/./;
console.log(pattern.exec(str));//null
数字字母下划线
/[a-zA-Z0-9_]/ = /w/
/[^a-zA-Z0-9_]/ = /W/
var str="@_";var pattern=/w/;
console.log(pattern.exec(str));//["_", index: 1, input: "@_", groups: undefined]
数字
/[0-9]/ = /d/
/[^0-9]/ = /D/
var str="@_123";var pattern=/d/;
console.log(pattern.exec(str));//["1", index: 2, input: "@_123", groups: undefined]
/ / 匹配空格
/ / 匹配 tab
/s/ 匹配空格或者制表符(tab)
/S/ 匹配除了空格或者制表符之外的其他字符
匹配的顺序取决于字符串中的顺序
var str=" 9";var pattern=/[ds]/;
console.log(pattern.exec(str));//[" ", index: 0, input: " 9", groups: undefined]
重复
{n} 表示量词,出现 n 次
var str="123456789";var pattern=/d{3}/;//匹配3个数字
console.log(pattern.exec(str));//["123", index: 0, input: "123456789", groups: undefined]
{n1, n2} 表示出现次数大于等于n1,小于等于n2
var str="123456789";var pattern=/d{2,3}/;//匹配2-3个数字,会尽可能多的匹配
console.log(pattern.exec(str));//["123", index: 0, input: "123456789", groups: undefined]
{n1, } 表示大于等于n1
{ ,n2 } 不表示小于等于n2,这种写法是错误的
var str="123456789";var pattern=/d{1,}/;
console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]
var pattern2=/d{,2}/;//这种写法是错误的
console.log(pattern2.exec(str));//null
? = {0,1} 匹配0次或者1次
var str="123456789";var pattern=/d?/;
console.log(pattern.exec(str));//["1", index: 0, input: "123456789", groups: undefined]
+ = {1,} 至少1次
var str="123456789";var pattern=/d+/;
console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]
* = 任意次(包括0次)
var str="123456789";var pattern=/d*/;
console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]
匹配价格
var str="肯德基豪华午餐¥15.5元";var pattern=/d+.?d*/;//前面的数字 至少有1位
//. 出现0次或者1次
//后面的数字 可以有也可以没有,任意次
console.log(pattern.exec(str));//["15.5", index: 8, input: "肯德基豪华午餐¥15.5元", groups: undefined]
匹配正整数和负整数
var str="肯德基豪华午餐¥15.5元";var pattern=/-?[1-9]d*/;var pattern=/-{0,1}[1-9]d*/;
非贪婪的重复
正则匹配默认是贪婪模式,存在量词时会尽可能多的匹配
var str="aaab";var pattern=/a+/;
console.log(pattern.exec(str));//["aaa", index: 0, input: "aaab", groups: undefined]
在量词后面加上 ? ,表示由贪婪模式转为非贪婪模式,尽可能少的匹配
var str="aaab";var pattern=/a+?/;
console.log(pattern.exec(str));//["a", index: 0, input: "aaab", groups: undefined]
但是正则有一个原则,就是去找第一个可能匹配的字符
而不是最合适的位置
var str="aaab";var pattern=/a+?b/;//此处并不会匹配到ab
console.log(pattern.exec(str));//["aaab", index: 0, input: "aaab", groups: undefined]
如上,并不会匹配到ab,因为正则从0开始就匹配到了a,之后会一直沿着下去寻找b
贪婪匹配与非贪婪匹配的应用
var str="
第一格第二格";var pattern=/.*/;//贪婪模式,匹配两格console.log(pattern.exec(str));//["
第一格第二格", index: 0, input: "第一格第二格", groups: undefined]var pattern2=/
.*?/;//非贪婪模式,匹配一格console.log(pattern2.exec(str));//["
第一格", index: 0, input: "第一格第二格", groups: undefined]选择 |
var str="css js";var pattern=/js|html|css/;
console.log(pattern.exec(str));//["css", index: 0, input: "css js", groups: undefined]
选择最先匹配的,而不是最合适的
var str="ab";var pattern=/a|ab/;//先尝试匹配a,匹配成功后,不再匹配ab
console.log(pattern.exec(str));//["a", index: 0, input: "ab", groups: undefined]
正则匹配上传图片的后缀名:一般图片的后缀名有gif,jpg,jpeg,png等,并且不区分大小写
/.gif|.jpg|.jpeg|.png/i
分组和引用 ()
var str="abab";var pattern=/(ab)+/;//将ab看成一个整体
console.log(pattern.exec(str));//(2) ["abab", "ab", index: 0, input: "abab", groups: undefined]
返回的数组中,第一个元素是匹配到的结果,第二个元素是 () 中分组的元素
( ) 捕获分组
(?: ) 不捕获分组
var str="abcd";var pattern=/(abc)d/;//匹配到abcd,捕获到abc
console.log(pattern.exec(str));//(2) ["abcd", "abc", index: 0, input: "abcd", groups: undefined]
var str="abcd";var pattern=/(?:abc)d/;//匹配到abcd,没有捕获
console.log(pattern.exec(str));//(2) ["abcd", index: 0, input: "abcd", groups: undefined]
平行分组依次返回
var str="abcd";var pattern=/(ab)(cd)/;//匹配到abcd,第一个分组ab,第二个分组cd
console.log(pattern.exec(str));//["abcd", "ab", "cd", index: 0, input: "abcd", groups: undefined]
嵌套分组,按左边括号的顺序来进行返回
var str="abcd";var pattern=/(a(b(c(d))))/;
console.log(pattern.exec(str));//(5) ["abcd", "abcd", "bcd", "cd", "d", index: 0, input: "abcd", groups: undefined]
可以在正则中直接使用分组 n 代表第n个分组
var str="abcdab";var pattern=/(ab)cd1/;//1代表第一个分组,即ab
console.log(pattern.exec(str));//(2) ["abcdab", "ab", index: 0, input: "abcdab", groups: undefined]
分组的实际应用
匹配外层容器中的html文本,外层容器是不确定的标签
var str="
这是html文本
console.log(pattern.exec(str));//["
这是html文本
这是html文本
", index: 0, input: "这是html文本
如上,第一个分组是外层标签名,第二个分组是获取到的内层html
.exec 返回的数组:
匹配到的结果
分组依次返回
index 匹配到的位置索引
input 被匹配的字符串
位置匹配之首尾匹配
^ 字符串的开始
$ 字符串的结束
var str="js";var pattern=/^js/;
console.log(pattern.exec(str));//["js", index: 0, input: "js", groups: undefined]
var str="html js";var pattern=/^js/;
console.log(pattern.exec(str));//null
匹配全是数字
var str="123mm567";var pattern=/^d+$/;
console.log(pattern.exec(str));//null
if(pattern.test(str)){
alert("全是数字");
}else{
alert("不全是数字");//不全是数字
}
反向思考,匹配不是数字
var str="123mm567";var pattern=/D/;
console.log(pattern.exec(str));//["m", index: 3, input: "123mm567", groups: undefined]
if(!pattern.test(str)){
alert("全是数字");
}else{
alert("不全是数字");//不全是数字
}
位置匹配之单词边界匹配
单词边界 b
非单词边界 B
var str="js html";var pattern=/jsb/;
console.log(pattern.exec(str));//["js", index: 0, input: "js html", groups: undefined]
var str="@@@js@@@";//@也属于单词边界
var pattern=/bjsb/;
console.log(pattern.exec(str));//["js", index: 0, input: "js html", groups: undefined]
实现可兼容IE低版本的 getElementsByClassName()
Document- 1
- 2
- 3
- 4
functiongetByClass(className,node){//高版本浏览器
if(document.getElementsByClassName(className)){returndocument.getElementsByClassName(className)
}else{//IE低版本浏览器
var node=node ||document;var arr=[];var elements=node.getElementsByTagName("*");//获取所有元素
//注意,使用构造函数创建正则,其中的转义字符需要进行双重转义
var pattern=new RegExp("(^|\s+)"+className+"($|\s+)");for(var i=0;i
if(pattern.test(elements[i].className)){
arr.push(elements[i]);
}
}returnarr;
}
}var odds=getByClass("odd");for(var i=0;i
odds[i].style.background="pink";
}var evens=getByClass("even");for(var i=0;i
evens[i].style.background="#abcdef";
}
使用单词边界的思路也可实现
Document- 1
- 2
- 3
- 4
functiongetByClass(className,node){//高版本浏览器
if(document.getElementsByClassName(className)){returndocument.getElementsByClassName(className)
}else{//IE低版本浏览器
var node=node ||document;var arr=[];var elements=node.getElementsByTagName("*");//获取所有元素
//注意,使用构造函数创建正则,其中的转义字符需要进行双重转义
var pattern=new RegExp("\b"+className+"\b");for(var i=0;i
if(pattern.test(elements[i].className)){
arr.push(elements[i]);
}
}returnarr;
}
}var odds=getByClass("odd");for(var i=0;i
odds[i].style.background="pink";
}var evens=getByClass("even");for(var i=0;i
evens[i].style.background="#abcdef";
}
前瞻性匹配 (?= )
var str="javascript";var pattern=/java(?=script)/;//如果java后面跟的是script,那么匹配出java
console.log(pattern.test(str));//true
var str="java";var pattern=/java(?=script)/;//如果java后面跟的是script,那么匹配出java
console.log(pattern.test(str));//false
负前瞻性匹配 (?!)
var str="javascript";var pattern=/java(?!script)/;//如果java后面跟的是script,那么不匹配出java
console.log(pattern.test(str));//false
var str="java";var pattern=/java(?!script)/;//如果java后面跟的不是script,那么匹配出java
console.log(pattern.test(str));//true
RegExp 对象的实例方法
其中的转义字符需要进行双重转义
var pattern=new RegExp("b");
console.log(pattern);
var pattern=new RegExp("\b");
console.log(pattern);///b/
因此,如果是 ,直面量方式转义为 \,构造函数双重转义为 \\
var pattern=new RegExp("\\");
console.log(pattern);///\/
pattern 就是正则实例的对象,pattern 拥有的方法就是实例方法
如: .test() .exec()
var str="js js js";var pattern=/js/;
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
var pattern=/js/g;
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 3, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//["js", index: 4, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//null
console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]
如上,exec 有一个属性,叫 lastIndex,默认是0
如果设置为全局匹配,则 lastIndex 是上一次匹配的结束位置的下一位
如果匹配到为 null,就会自动重置为0,再次进行下一轮
分组之后也能捕获
var str="js js js";var pattern=/(j)s/;
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
var pattern=/(j)s/g;
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 3, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//(2) ["js", "j", index: 6, input: "js js js", groups: undefined]
console.log(pattern.exec(str));//null
console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]
实例:
var str="1.js 2.js 3.js";var pattern=/js/g;var total=0;//出现的总次数
varresult;while((result=pattern.exec(str))!=null){//先赋值再进行判断
total++;
console.log(result[0]+"第"+total+"次出现的位置是:"+result.index);
}
console.log("总共出现了"+total+"次");
test 与 exec 类似原理
var str="js js js";var pattern=/js/;
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
var pattern=/js/g;
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
console.log(pattern.test(str));//true
console.log(pattern.test(str));//false
console.log(pattern.test(str));//true
.toString() 转字符串
.toLocaleString() 转本地字符串(仅限少数语言)
.valueOf() 返回正则本身
var pattern=new RegExp("a\nb");
console.log(pattern.toString());///anb/ 此处返回的是字面量形式的字符串
console.log(pattern.toLocaleString());///anb/
console.log(pattern.valueOf());///anb/
console.log(pattern.valueOf()===pattern);//true
实例属性
.ignoreCase 判断是否忽略大小写
.global 是否全局
.multiline 是否匹配到多行
.source 返回字面量正则本身
var str="js js js";var pattern=/js/im;
console.log(pattern.ignoreCase);//true
console.log(pattern.global);//false
console.log(pattern.multiline);//true
console.log(pattern.source);//js
console.log(pattern.source===pattern);//false
.lastIndex 最后一次匹配的位置的后一位
var str="js js";var pattern=/js/;
console.log(pattern.lastIndex);//0
pattern.test(str);
console.log(pattern.lastIndex);//0
pattern.test(str);
console.log(pattern.lastIndex);//0
pattern.test(str);
console.log(pattern.lastIndex);//0
pattern.test(str);
console.log(pattern.lastIndex);//0
var pattern=/js/g;
console.log(pattern.lastIndex);//0
pattern.test(str);
console.log(pattern.lastIndex);//2
pattern.test(str);
console.log(pattern.lastIndex);//5
pattern.test(str);
console.log(pattern.lastIndex);//0 匹配不到时重置到0
pattern.test(str);
console.log(pattern.lastIndex);//2
构造函数属性 RegExp.
.input 待匹配的字符串 = $_
.lastMatch 最近一次匹配到的字符 = $&
.leftContext 最近一次匹配时左边的字符 = $`
.rightContext 最近一次匹配时右边的字符 = $'
.lastParen 最近一次匹配到的子选项(分组中的内容) = $+
.$n 捕获分组
var str="js js";var pattern=/(j)s/;
pattern.exec(str);//待匹配的字符串
console.log(RegExp.input);//js js
console.log(RegExp["$_"]);//js js
//最近一次匹配到的字符
console.log(RegExp.lastMatch);//js
console.log(RegExp["$&"]);//js
//最近一次匹配时左边的字符
console.log(RegExp.leftContext);//空
console.log(RegExp["$`"]);//空
//最近一次匹配时右边的字符
console.log(RegExp.rightContext);//js
console.log(RegExp["$'"]);//js
//最近一次匹配到的子选项(分组中的内容)
console.log(RegExp.lastParen);//j
console.log(RegExp["$+"]);//j
//捕获分组
console.log(RegExp.$1);//j
string 对象中,与正则相关的方法
str.search() 与是否全局无关,只查找一个,如果有,就返回 index
如果没有,就返回 -1
var str="js js";var pattern=/(j)s/;
console.log(str.search(pattern));//0
var pattern=/aa/;
console.log(str.search(pattern));//-1
str.match()
普通匹配时与 exec 相同
全局匹配时:直接返回所有匹配的元素,分组会失效
var str="js js";var pattern=/(j)s/;
console.log(str.match(pattern));//(2) ["js", "j", index: 0, input: "js js", groups: undefined]
var pattern=/aa/;
console.log(str.match(pattern));//null
var pattern=/(j)s/g;
console.log(str.match(pattern));//(2) ["js", "js"]
var pattern=/aa/;
console.log(str.match(pattern));//null
str.match( pattern )
非全局匹配时才能返回分组中的内容
全局匹配时会返回所有匹配到的字符
m 和 g 组合,结合首尾匹配,体现
var str="1.jsn2.jsn3.js";var pattern=/js$/g;//匹配行尾的js,默认是一行
console.log(str.match(pattern));//["js"]
var pattern=/js$/mg;//匹配行尾的js,默认是多行
console.log(str.match(pattern));//(3) ["js", "js", "js"]
str.split() 字符串分割,转为数组
var str="1,2,3";
console.log(str.split(","));//(3) ["1", "2", "3"]
var str="1, 2 , 3";var pattern=/s*,s*/g;
console.log(str.split(pattern));//(3) ["1", "2", "3"]
str.replace()
var str="i love js js";
console.log(str.replace("js","html"));//i love html js
var pattern=/js/g;
console.log(str.replace(pattern,"html"));//i love html html
replace 替换时间格式
var str="2020-2-15";var pattern=/-/g;
console.log(str.replace(pattern,"/"));//2020/2/15
使用 $n 进行分组引用
var str="i love pink";var pattern=/(pink)/g;
document.write(str.replace(pattern,"$1"));
敏感词的过滤
var str="中国军队和阿扁一起办证";var pattern=/国军|阿扁|办证/g;
document.write(str.replace(pattern,"*"));//中*队和*一起*
一个文字对应一个 * 号
$0 是每次匹配到的内容
var str="中国军队和阿扁一起办证";var pattern=/国军|阿扁|办证/g;
document.write(str.replace(pattern,function($0){
console.log($0);var result="";for(var i=0;i
result+="*";
}returnresult;
}));//中**队和**一起**
f5 浅刷新
ctrl+f5 深度刷新
常用的正则表达式:
1、QQ号:
全数字 首位不是0 最少5位 (目前最多11位,以后可能会扩增)
/^[1-9]d{4,10}$/
/^[1-9]d{4,}$/
2、用户名、昵称
2-18位 中英文数字及下划线组成
/^[ue400-u9fa5w]{2,18}$/
/^[ue400-u9fa5a-zA-Z0-9_]{2,18}$/
3、密码
6-16位 不能有空白符 区分大小写
/^S{6,16}$/
4、去除字符串首尾的空白字符
首先是去除首部或者尾部
var str=" cyy ";
console.log("|"+str+"|");//| cyy |
var pattern=/^s+/;
str=str.replace(pattern,"");//替换左边空白符
var pattern2=/s+$/;/*这里使用 s+ 比使用 s* 效率高
s* 无论如何都会进行替换,哪怕没有空白符
s+ 只在有空白符的时候进行替换,否则直接返回*/str=str.replace(pattern2,"");//替换右边空白符
console.log("|"+str+"|");//|cyy|
同时去除首尾空白符
var str=" cyy ";
console.log("|"+str+"|");//| cyy |
var pattern=/^s+|s+$/g;
str=str.replace(pattern,"");//替换左右空白符
console.log("|"+str+"|");//|cyy|
var str=" cyy ";
console.log("|"+str+"|");//| cyy |
functiontrim(str){return str.replace(/^s+/,"").replace(/s+$/,"");
}
console.log("|"+trim(str)+"|");//|cyy|
5、转驼峰
str.replace(pattern, 要替换的内容) 第二个参数可以是一个匿名函数的返回值
匿名函数的参数中,第一个参数是匹配的内容,第二个参数开始是分组捕获的内容
var str="background-color";var pattern=/-([a-z])/gi;发表于 2020-02-16 00:20
阅读 ( 195 )
推荐
收藏