最近又在重新复习js，不怎么用有些就就生疏了，每天都要复习复习在复习才行，分享一下跟着大神学习的日常笔记记录。
有些錯誤可能是沒寫對中英字符，可能會報錯，都手寫的，見諒，废话不多说半句，开始复习吧！
正则的创建方式有两种：
1：var reg = /pattem/;
2:var reg = new RegExp('pattem');
RegExp对象的常用方法：
exec（str）：检索字符串中制定的值，返回找到的值，并确定其位置。
test（str）：检索字符串中是否有满足指定条件的值，并返回true或false。
如下例子：
var str="lihezhu";
var reg = /li/;
alert（reg.exec(str)）;//li
alert（reg.test(str)）;//true正则表达式所支持的常用通配符：
| . | 可以匹配任何字符 |
| \d | 匹配0-9的所有数字,等於[0-9] |
| \D | 匹配非数字，等於[^0-9] |
| \s | 匹配所有空白字符，包括空格，制表符\t，换行符\n，回车符\r，換頁符\f，垂直制表符\v等與：[\t\f\v\n\r ] |
| \S | 匹配所有非空白字符[^\t\f\v\n\r ] |
| \w | 匹配所有的单词字符，包括0-9数字，26个英文字母和下划线(0-9A-z_) |
| \W | 匹配所有的非单词字符 |
| \b | 匹配单词边界 |
| \B | 匹配非单词边界 |
1：. 的用法
var str="lihezhu";
var reg = /./;
alert（reg.test(str)）;//true注意：str里面有一个值则为true，如为空则为false
1-2:.的用法
var str="That's hot!";
var patt1=/h.t/g;
document.write(str.match(patt1));結果為：
hat,hot2-1：\d的用法
var str="123456";
var reg = /\d/;
alert（reg.test(str)）;//true注意：str里面有一个为数字则为true
2-2：\d的用法
var str="4a";
var reg = /\d/;
alert（reg.test(str)）;//true注意：str里面有一个为数字则为true
2-3：\d
var str="Give 100%!";
var patt1=/\d/g;
document.write(str.match(patt1));結果為：
1,0,03-1：\D的用法
var str="123456k";
var reg = /\D/;
alert（reg.test(str)）;//true注意：str里面有一个为数字则为true
3-2：\D的用法
var str="123456";
var reg = /\D/;
alert（reg.test(str)）;//false注意：str里面全为数字则为false
4：\s的用法
var str="12 34 56";
var reg = /\s/;
alert（reg.test(str)）;//true5：\S的用法
var str="123456";
var reg = /\S/;
alert（reg.test(str)）;//true6-1：\b的用法
var str="lihezhu";
var reg = /\bl/;
alert（reg.test(str)）;//true注意：str里面开头为l开头
6-2：\b的用法
var str="lihezhu";
var reg = /u\b/;
alert（reg.test(str)）;//true注意：str里面最后一个字符为u开头
7-1:\w
var str = "ab1cd";
var reg =/\w/g;
console.log(str.match(reg))結果為：
7-2：\w
var str="Give 100%!";
var patt1=/\w/g;
document.write(str.match(patt1));結果為：
G,i,v,e,1,0,07-3：\w
var str = "ab1cd";
var reg =/\wb1cd/g;
console.log(str.match(reg))結果為：
8-1：\W
var str = "a#b1cd";
var reg =/\Wb1cd/g;
console.log(str.match(reg))結果為：
8-2：\W
var str = "a#b1cd";
var reg =/\W/g;
console.log(str.match(reg))結果為：
9-1:\t
var str = "a#b\t1cd";
var reg =/\t1cd/g;
console.log(str.match(reg))結果為：
10-1:\n
var str="Visit W3School.\n Learn JavaScript.";
var patt1=/\n/g;
document.write(str.search(patt1));結果為：
15*正则表达式所支持的常用通配符
| [abc] | 查找方括号之间的任何字符 |
| [^abc] | 查找任何不在方括号之间的字符 |
| [0-9] | 查找任何从0-9的数字 |
| [a-z] | 查找任何从小写a到小写z的字符 |
| [A-Z] | 查找任何从大写A到大写Z的字符 |
| [A-z] | 查找任何从大写A到小写z的字符 |
| (red|green|yellow) | 查找任何指定的选项 |
1-1：[abc]的用法
var str="lihezhu";
var reg = /[lh]/;
alert（reg.test(str)）;//true注意：匹配到一个就可以
1-2：[abc]的用法
var str="lihezhu";
var reg = /[lx]/;
alert（reg.test(str)）;//true注意：有l满足就可以
1-3：[abc]的用法
var str = "abcd";
var reg =/[ab][cd][d]/g;
console.log(str.match(reg))結果為：
1-4：[abc]的用法
var str="Is this all there is?";
var patt1=/[a-h]/g;
document.write(str.match(patt1));結果為：
h,a,h,e,e2-1：[^abc]的用法
var str="lihezhu";
var reg = /[^lx]/;
alert（reg.test(str)）;//true注意：ihezhu为非reg里的，有一个满足不在reg 里面就为true
2-2：[^abc]的用法
var str="lihezhu";
var reg = /[^lihezhu]/;
alert（reg.test(str)）;//false注意：这个就为false了，因为reg里面的单词在str里面都有。
3-1：[0-9]的用法
var str="123456";
var reg = /[0-9]/;
alert（reg.test(str)）;//true注意：有一个为数字，则为true
3-2：[0-9]的用法
var str="1abc";
var reg = /[0-9]/;
alert（reg.test(str)）;//true注意：有一个为数字，则为true
4：[A-Z]的用法
var str="a";
var reg = /[A-Z]/;
alert（reg.test(str)）;//false单词这个比较jia简单，都差不多一个意思就不多说，说下最后一个重点：
5：(red|green|yellow)的用法
var str="reda";
var reg = /(red|green|yellow)/;
alert（reg.test(str)）;//true注意：只要其中一个条件满足则为true，记得要加括号，不然会出错哈~~~
*正则表达式量词：
| n+ | 匹配任何包含至少一个n的字符串 |
| ?=n | 匹配任何其后紧接指定字符串 n 的字符串。 |
| ?!n | 匹配任何其后没有紧接指定字符串 n 的字符串。 |
| n* | 匹配任何包含零个或多个n的字符串 |
| n? | 匹配任何包含零个或一个n的字符串 |
| n{X} | 匹配包含X个n的序列的字符串 |
| n{X,Y} | 匹配包含X或Y个n的序列的字符串 |
| n{X,} | 匹配包含至少X个n的序列的字符串 |
| n$ | 匹配任何结尾为n的字符串 |
| ^n | 匹配任何开头为n的字符串 |
{4,7} 最少出现4次，最多出现7次
{4,} 最少出现4次
{4} 正好出现4次
+是{}的简写，相当于(1,)
? 相当于{0,1} //出现0次或者1次
* 相当于{0,} //至少出现0次，可以没有
(?=) :前向声明
(?!):反前向声明
1-1：n+的用法
var str="aabbcc";
var reg = /a+/;
alert（reg.test(str)）;//true1-2：n+的用法
var str="bbcc";
var reg = /a+/;
alert（reg.test(str)）;//false1-3：n+的用法
var str="Hellooo World! Hello W3School!";
var patt1=/o+/g;
document.write(str.match(patt1));結果：
ooo,o,o,oo1-4：n+的用法
var str="Hellooo World! Hello W3School!";
var patt1=/\w+/g;
document.write(str.match(patt1));結果：
Hellooo,World,Hello,W3School2-1：n*的用法
var str="aabbcc";
var reg = /a*/;
alert（reg.test(str)）;//true2-2：n*的用法（对 "l" 进行全局搜索，包括其后紧跟的一个或多个 "o"）
var str="Hellooo World! Hello W3School!";
var patt1=/lo*/g;
document.write(str.match(patt1));結果：
l,looo,l,l,lo,l2-3：n*的用法 （对 "1" 进行全局搜索，包括其后紧跟的一个或多个 "0"）
var str="1, 100 or 1000?";
var patt1= /10*/g;
document.write(str.match(patt1));結果：
1,100,10003-1：n?的用法
var str="bbcc";
var reg = /a*/;
alert（reg.test(str)）;//true3-2：n?的用法(对 "1" 进行全局搜索，包括其后紧跟的零个或一个 "0")
var str="1, 100 or 1000?";
var patt1=/10?/g;
document.write(str.match(patt1))//1,10,104-1：n{X}的用法
var str="aabbcc";
var reg = /a{2}/;
alert（reg.test(str)）;//true（a要在一个序列，并在这个序列要包含2个a）4-2：n{X}的用法
var str="aabbcc";
var reg = /a{3}/;
alert（reg.test(str)）;//false4-3：n{X}的用法
var str="100, 1000 or 10000?";
var patt1=/\d{4}/g;
document.write(str.match(patt1));//1000,10005-1：n{X,}的用法
var str="aabbcc";
var reg = /a{2,}/;
alert（reg.test(str)）;//true(至少包含2个a)5-2：n{X,}的用法
var str="abbcc";
var reg = /a{2,}/;
alert（reg.test(str)）;//false(至少包含2个a)5-3：n{X,}的用法
var str="100, 1000 or 10000?";
var patt1=/\d{3,}/g;
document.write(str.match(patt1));//100,1000,100006-1：n{X,Y}的用法
var str="aabbcc";
var reg = /a{1,3}/;
alert（reg.test(str)）;//true(最多3个a)6-2：n{X,Y}的用法 (三位至四位数字序列的子串进行全局搜索)
var str="100, 1000 or 10000?";
var patt1=/\d{3,4}/g;
document.write(str.match(patt1));//100,1000,10007-1：^n的用法
var str="aabbcc";
var reg = /^a/;
alert（reg.test(str)）;//true(确实是从a开头的）7-2：^n的用法
var str="aabbcc";
var reg = /^b/;
alert（reg.test(str)）;//false8-1：n$的用法
var str="aabbcc";
var reg = /c$/;
alert（reg.test(str)）;//true(确实是从c结尾的）8-2：n$的用法
var str="aabbcc";
var reg = /m$/;
alert（reg.test(str)）;//false9-1:?= 量词(对其后紧跟 "all" 的 "is" 进行全局搜索)
var str="Is this all there is";
var patt1=/is(?= all)/;
document.write(str.match(patt1));//this中的is9-2：
var str="abacad";
var re=/a(?=b)/g;
str=str.replace(re,"*");
alert(str);//*bacad10-1：?! 量词（对其后没有紧跟 "all" 的 "is" 进行全局搜索）
var str="Is this all there is";
var patt1=/is(?! all)/gi;
document.write(str.match(patt1));//Is,is結果：
10-2
var str="abacad";
var re=var re=/a(?!b)/g;
str=str.replace(re,"*");
alert(str);//ab*c*d*正则表达式修饰符
| i | 执行对大小写不敏感的匹配 |
| g | 执行全局匹配（查找所有匹配而非在找到一个匹配就停止） |
| m | 执行多行匹配 |
1-1：i的用法
var str="AAbbcc";
var reg = /a/i;
alert（reg.test(str)）;//true
2-1：g的用法
var str="abaa";
var reg = /a/g;
alert（reg.test(str)）;//true
alert（reg.test(str)）;//true
alert（reg.test(str)）;//true
alert（reg.test(str)）;//false（因为全局只有3个a，所以为false）2-2：g的用法
var str = "12309u98732zpoixcup";
var reg =/[0-9][0-9][0-9]/g;
console.log(str.match(reg))
結果為：前面的數字匹配好了就不在匹配了
3-1：m的用法
var str="b\naa";
var reg = /^a/m;
alert（reg.test(str)）;//true(第一行b开头没有a，第二行开头有a，故为true)3-2：m的用法
var str = "a\naa";
var reg = /^a/gm;//在這裡加m才具有多行匹配功能
console.log(str.match(reg))結果為：
小練習：
1-1：好了了解了这么多，开始实战个简单的邮箱把：
var reg = /^[0-9A-z_-]+@[0-9A-z_-]+\.(com|cn|org)$/
console.log(reg.test(112233zz@163.com))//true
console.log(reg.test(112233zz163.com))//false（少了@符号）1-2：
var str = "ab1cd";
var reg =/[0-9A-z][cd][d]/g;
console.log(str.match(reg))結果為：
1-3：
var str = "ab1cd";
var reg =/[^a][^b]/g;
console.log(str.match(reg))結果為：
1-4：
var str = "ab1cd";
var reg =/[^a][^b][^c]/g;
console.log(str.match(reg))結果為;
1-5：aabb轉換為bbaa
var str = 'aabb';
var reg = /(\w)\1(\w)\2/g;
console.log(str.replace(reg, '$2$2$1$1'))//bbaa,注意\1是複製前面的值1-6：把the-happly-day換成theHappleDay
var str = 'the-happly-day';
var reg = /-(\w)/g;
console.log(str.replace(reg, function($,$1){
return $1.toUpperCase();//theHapplyDay1-7：把aaaaabbbbbbcccccccddddddd換成abcd，去重
var str = 'aaaaabbbbbbcccccccddddddd';
var reg = /(\w)\1*/g;
console.log(str.replace(reg, function($,$1){
return $1//abcd
})) 1-8：把10000000000換成10.000.000.000
var str = '10000000000';
var reg = /(?=(\B)(\d{3})+$)/g;
console.log(str.replace(reg,'.')) //10.000.000.000（注意必須是非單詞邊界，不然還有bug）1-9：1 plus 2 equal 3換成1,2,3
var str="1 plus 2 equal 3"
document.write(str.match(/\d+/g))* 支持正则表达式的 String 对象的方法
| 方法 | 描述 | FF | IE |
|---|---|---|---|
| search | 检索与正则表达式相匹配的值。 | 1 | 4 |
| match | 找到一个或多个正则表达式的匹配。 | 1 | 4 |
| replace | 替换与正则表达式匹配的子串。 | 1 | 4 |
| split | 把字符串分割为字符串数组。 | 1 | 4 |
1: search() 方法
定义和用法
search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。
语法
stringObject.search(regexp)| 参数 | 描述 |
|---|---|
| regexp | 该参数可以是需要在 stringObject 中检索的子串，也可以是需要检索的 RegExp 对象。 注释：要执行忽略大小写的检索，请追加标志 i。 |
返回值
stringObject 中第一个与 regexp 相匹配的子串的起始位置。
注释：如果没有找到任何匹配的子串，则返回 -1。
说明
search() 方法不执行全局匹配，它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性，并且总是从字符串的开始进行检索，这意味着它总是返回 stringObject 的第一个匹配的位置。
1-1：
var str="Visit W3School!"
document.write(str.search(/W3School/))//61-2:无法检索到 w3school（因为 search() 对大小写敏感）
var str="Visit W3School!"
document.write(str.search(/w3school/))//-11-3:忽略大小写的检索
var str="Visit W3School!"
document.write(str.search(/w3school/i))//62:match
定义和用法
match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。
该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。
语法
stringObject.match(searchvalue)
stringObject.match(regexp)| 参数 | 描述 |
|---|---|
| searchvalue | 必需。规定要检索的字符串值。 |
| regexp | 必需。规定要匹配的模式的 RegExp 对象。如果该参数不是 RegExp 对象，则需要首先把它传递给 RegExp 构造函数，将其转换为 RegExp 对象。 |
返回值
存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。
说明
match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。
如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。
如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。
注意：在全局检索模式下，match() 即不提供与子表达式匹配的文本的信息，也不声明每个匹配子串的位置。如果您需要这些全局检索的信息，可以使用 RegExp.exec()。
1：對"Hello world!" 中进行不同的检索
var str="Hello world!"
document.write(str.match("world") + "<br />")
document.write(str.match("World") + "<br />")
document.write(str.match("worlld") + "<br />")
document.write(str.match("world!"))輸出：
world
null
null
world!2：将使用全局匹配的正则表达式来检索字符串中的所有数字
var str="1 plus 2 equal 3"
document.write(str.match(/\d+/g))//1,2,3
3:replace() 方法
定义和用法
replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
语法
stringObject.replace(regexp/substr,replacement)| 参数 | 描述 |
|---|---|
| regexp/substr | 必需。规定子字符串或要替换的模式的 RegExp 对象。 请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。 |
| replacement | 必需。一个字符串值。规定了替换文本或生成替换文本的函数。 |
返回值
一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。
说明
字符串 stringObject 的 replace() 方法执行的是查找并替换的操作。它将在 stringObject 中查找与 regexp 相匹配的子字符串，然后用 replacement 来替换这些子串。如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。
replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。
| 字符 | 替换文本 |
|---|---|
| $1、$2、...、$99 | 与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。 |
| $& | 与 regexp 相匹配的子串。 |
| $` | 位于匹配子串左侧的文本。 |
| $' | 位于匹配子串右侧的文本。 |
| $$ | 直接量符号。 |
注意：ECMAScript v3 规定，replace() 方法的参数 replacement 可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有 0 个或多个这样的参数。接下来的参数是一个整数，声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。
1:将使用 "W3School" 替换字符串中的 "Microsoft"
var str="Visit Microsoft!"
document.write(str.replace(/Microsoft/, "W3School"))//Visit W3School!2:执行一次全局替换，每当 "Microsoft" 被找到，它就被替换为 "W3School"
var str="Welcome to Microsoft! "
str=str + "We are proud to announce that Microsoft has "
str=str + "one of the largest Web Developers sites in the world."
document.write(str.replace(/Microsoft/g, "W3School"))
結果：
Welcome to W3School! We are proud to announce that W3School
has one of the largest Web Developers sites in the world.3：匹配字符串大写字符的正确
text = "javascript Tutorial";
text.replace(/javascript/i, "JavaScript");4：将把 "Doe, John" 转换为 "John Doe" 的形式
name = "Doe, John";
document.write(name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1"));結果：
John Doe5-1：将把所有的花引号替换为直引号
name = '"a", "b"';
document.write(name.replace(/"([^"]*)"/g, "'$1'"));//'a', 'b'5-2：将把所有的花引号替换为雙引号
name = '"a", "b"';
document.write(name.replace(/([^"]*)/g, '$1'));//"a", "b"6-1：如何使用 replace() 把单词的首字母转换为大写
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
return word.substring(1).toUpperCase()+word.substring(1);}
);
document.write (uw);//Aaa Bbb Ccc4：split() 方法
定义和用法
split() 方法用于把一个字符串分割成字符串数组。
语法
stringObject.split(separator,howmany)| 参数 | 描述 |
|---|---|
| separator | 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。 |
| howmany | 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。 |
返回值
一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。
但是，如果 separator 是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）。
提示和注释
注释：如果把空字符串 ("") 用作 separator，那么 stringObject 中的每个字符之间都会被分割。
注释：String.split() 执行的操作与 Array.join 执行的操作是相反的。
1：按照不同的方式来分割字符串
var str="How are you doing today?"
document.write(str.split(" ") + "<br />")
document.write(str.split("") + "<br />")
document.write(str.split(" ",3))結果：
How,are,you,doing,today?
H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
How,are,you2：
"2:3:4:5".split(":") //将返回["2", "3", "4", "5"]
"|a|b|c".split("|") //将返回["", "a", "b", "c"]3：可以把句子分割成单词
var sentence="How are you doing today?";
var words = sentence.split(/\s+/).join(" ")
document.write(words)//How are you doing today?4：
"hello".split("") //可返回 ["h", "e", "l", "l", "o"]
"hello".split("", 3) //可返回 ["h", "e", "l"]小練習：
1：
1 Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3 InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号(15位、18位数字)：^\d{15}|\d{18}$
8 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12 日期格式：^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
14 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
15 钱的输入格式：
16 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26 中文字符的正则表达式：[\u4e00-\u9fa5]
27 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
28 空白行的正则表达式：\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
30 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
31 腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
32 中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
33 IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)
34 IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))以下轉自《JavaScript正则表达式的分组匹配详解》一文
2
var reg = /I love (him|her|it)/;
reg.test('I love him') // true
reg.test('I love her') // true
reg.test('I love it') // true
reg.test('I love them') // false这里的|相当于“或”的意思
3：匹配kidkidkid
/(kid){3}/4：捕获与引用
被正则表达式匹配（捕获）到的字符串会被暂存起来。其中，由分组捕获的串会从1开始编号，于是我们可以引用这些串
var reg = /(\d{4})-(\d{2})-(\d{2})/
var date = '2010-04-12'
reg.test(date)
RegExp.$1 // 2010
RegExp.$2 // 04
RegExp.$3 // 12$1引用了第一个被捕获的串，$2是第二个，依次类推。
5：与replace配合
var reg = /(\d{2}).(\d{2})\/(\d{4})/
var date = '12.21/2012'
date = date.replace(reg, '$3-$1-$2') // date = 2012-12-216： 敏感词过滤
将违禁词转换为等字数的星号是一个常见功能。比如文本是kid is a doubi，其中kid与doubi是违禁词，那么转换后应该为*** is a *****
var reg = /(kid|doubi)/g
var str = 'kid is a doubi'
str = str.replace(reg, function(word){
return word.replace(/./g, '*')
})
document.write(str)//*** is a ***** 栗子二：
var str = "aaahhhhaaaa";
var re = /a/g;
var aa=str.replace(re,"*");
console.log(aa)結果：
7：嵌套分组的捕获
碰到类似/((kid) is (a (doubi)))/的嵌套分组，捕获的顺序是什么？
var reg = /((kid) is (a (doubi)))/
var str = "kid is a doubi"
reg.test( str ) // true
RegExp.$1 // kid is a doubi
RegExp.$2 // kid
RegExp.$3 // a doubi
RegExp.$4 // doubi规则是以左括号出现的顺序进行捕获。
8-1：正则表达式里也能进行引用，这称为反向引用
var reg = /(\w{3}) is \1/
reg.test('kid is kid') // true
reg.test('dik is dik') // true
reg.test('kid is dik') // false
reg.test('dik is kid') // false\1引用了第一个被分组所捕获的串，换言之，表达式是动态决定的。
8-2：注意，如果编号越界了，则会被当成普通的表达式
var reg = /(\w{3}) is \6/;
reg.test( 'kid is kid' ); // false
reg.test( 'kid is \6' ); // true分组有四种类型：
- 捕获型 - ()
- 非捕获型 - (?:)
- 正向前瞻型 - (?=)
- 反向前瞻型 - (?!)
我们之前说的都是捕获型分组，只有这种分组会暂存匹配到的串。
非捕获型分组
有时候，我们只是想分个组，而没有捕获的需求，则可以使用非捕获型分组，语法为左括号后紧跟?:
var reg = /(?:\d{4})-(\d{2})-(\d{2})/
var date = '2012-12-21'
reg.test(date)
RegExp.$1 // 12
RegExp.$2 // 21(?:\d{4})分组不会捕获任何串，所以$1为(\d{2})捕获的串。
正向与反向前瞻型分组
肯定表达式与否定表达式。先举个正向前瞻的例子
var reg = /kid is a (?=doubi)/
reg.test('kid is a doubi') // true
reg.test('kid is a shabi') // falsekid is a 后面跟doubi才能匹配成功。
负向前瞻则刚好相反：
var reg = /kid is a (?!doubi)/
reg.test('kid is a doubi') // false
reg.test('kid is a shabi') // true前瞻型分组也不会捕获值。那么它与非捕获型的区别是什么？
var reg, str = "kid is a doubi"
reg = /(kid is a (?:doubi))/
reg.test(str)
RegExp.$1 // kid is a doubi
reg = /(kid is a (?=doubi))/
reg.test(str)
RegExp.$1 // kis is a可见，非捕获型分组匹配到的串，仍会被外层的捕获型分组捕获到，但前瞻型却不会。当你需要参考后面的值，又不想连它一起捕获时，前瞻型分组就派上用场了。
去空格的正则表达式
rstr=rstr.replace(/(^\s*)|(\s*$)/g,"")去左空格
replace(/(^\s*)/g, "");
去右空格
replace(/(\s*$)/g, ""); 獲取test
var str = "abcdefgname='test'sddfhskshjsfsjdfps";
var reg = /name='((\w|-|\s)+)'/ig;
str.replace(reg, function() {
console.log(arguments.length); //5
console.log(arguments[1]);//test
}); 获取全部分组内容的方法示例
var r = /\{ab(\d)ab}/g;
while ((resultS2 = r.exec("ab{ab8ab}c{ab9ab}")) != null) {
console.log(resultS2[1]);
} 結果：
替换掉小括号及内容的方法
var str = "hello(world)";
var nstr = str.replace(/\([^\)]*\)/g, "vue");
console.log(nstr)結果：
檢測一個字符串首尾都含有數字
var str = "3dddg3";
var reg = /^\d[\s\S]*\d$/g;
console.log(str.match(reg))結果：
注意任意字符可以用 [\s\S]代替
以下轉自《JS正则表达式验证数字（非常全）》
验证数字的正则表达式集
验证数字：^[0-9]*$
验证n位的数字：^\d{n}$
验证至少n位数字：^\d{n,}$
验证m-n位的数字：^\d{m,n}$
验证零和非零开头的数字：^(0|[1-9][0-9]*)$
验证有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
验证有1-3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
验证非零的正整数：^\+?[1-9][0-9]*$
验证非零的负整数：^\-[1-9][0-9]*$
验证非负整数（正整数 + 0） ^\d+$
验证非正整数（负整数 + 0） ^((-\d+)|(0+))$
验证长度为3的字符：^.{3}$
验证由26个英文字母组成的字符串：^[A-Za-z]+$
验证由26个大写英文字母组成的字符串：^[A-Z]+$
验证由26个小写英文字母组成的字符串：^[a-z]+$
验证由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
验证由数字、26个英文字母或者下划线组成的字符串：^\w+$
验证用户密码:^[a-zA-Z]\w{5,17}$ 正确格式为：以字母开头，长度在6-18之间，只能包含字符、数字和下划线。
验证是否含有 ^%&',;=?$\" 等字符：[^%&',;=?$\x22]+
验证汉字：
^[\u4e00-\u9fa5],{0,}$ 验证Email地址：
/^([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,3}$/验证InternetURL：
^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$ ；^[a-zA-z]+://(w+(-w+)*)(.(w+(-w+)*))*(?S*)?$ 验证电话号码：
^(\d3,4|\d{3,4}-)?\d{7,8}$
//正确格式为：XXXX-XXXXXXX，XXXX-XXXXXXXX，XXX-XXXXXXX，XXX-XXXXXXXX，XXXXXXX，XXXXXXXX。验证身份证号（15位或18位数字）：
^\d{15}|\d{}18$ 验证一年的12个月：
^(0?[1-9]|1[0-2])$
//正确格式为：“01”-“09”和“1”“12” 验证一个月的31天：
^((0?[1-9])|((1|2)[0-9])|30|31)$
//正确格式为：01、09和1、31。 整数：^-?\d+$
非负浮点数（正浮点数 + 0）：^\d+(\.\d+)?$
正浮点数
^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ 非正浮点数（负浮点数 + 0）
^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 负浮点数
^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ 浮点数
^(-?\d+)(\.\d+)?$如何获取一个字符串中的数字字符，并按数组形式输出
分析：循环用charAt()的方法获取到每一个子字符串，判断他是不是在0~9之间，是就把他扔到准备好的数组里
如：dgfhfgh254bhku289fgdhdy675gfh
输出[254,289,675]
var str = "dgfhfgh254bhku289fgdhdy675";
findNum(str);
function findNum() {
var arr = [];
var result = "";
for (var i = 0; i < str.length; i++) {
if (str.charAt(i) <= '9' && str.charAt(i) >= '0') {
result += str.charAt(i); //注意添加方向不要反了
}
else {
if (result) {
arr.push(result);
result = "";
}
}
}
if (str.charAt(i) <= '9' && str.charAt(i) >= '0') {
result += str.charAt(i); //注意添加方向不要反了
}
else {
if (result) {
arr.push(result);
result = "";
}
}
console.log(arr)
}結果：
每次碰到是数字走if，碰到字符走else，走else的时候把之前那些数字存放到新的空的字符串里，然后通过push添加到数组，然后清空字符串，一以便下次重新存放。
还有个隐患：如果最后以数字结尾，则最后不会进入else，最后几位数字会读不到，因此for循环外面再添加一遍else里面的if循环
检测一个字符串是不是全是数字
var str = '8t62t1564t61';
var re =/[A-z]/;
if (re.test(str)) {
alert("不全是数字");
}
else {
alert("全是数字");
}結果：
连着找到，而不是一个个分开
var re=/\d\d/g; //两个两个找
var re=/\d\d\d/g; //三个三个找个数不一定时怎么找，引进量词
量词：匹配不确定的位置
+：至少出现一次
var re=/\d+/g;找某个字符串中出现最多的字符和它一共出现多少次
var str = "vbbbbhybbfhbbgbbb";
var arr = str.split("");
str = arr.sort().join("");
var value = ""; //存放出现最多的字符
var index = 0; //存放次数
var re = /(\w)\1+/g;
str.replace(re, function ($0, $1) { //$0代表整体，$1代表第一个子项
if (index < $0.length) { //$0:每一组重复的元素
index = $0.length;
value = $1;
}
})
document.write('出现最多的字符是' + value + ',出现次数是' + index)結果：
以下轉自《JS常用正则表达式及验证时间的正则表达式》一文
1.在input框中只能输入金额，其实就是只能输入最多有两位小数的数字 //第一种在input输入框限制
<input type="text" maxlength="8" class="form-control" id="amount" style="margin-right: 2px;" value="" onChange="count();" onkeyup="if (this.value==this.value2) return; if (this.value.search(/^\d*(?:\.\d{0,2})?$/)==-1) this.value=(this.value2)?this.value2:'';else this.value2=this.value;">元
//第二种对于表单动态增加的方式，只能在js方法中验证。
var amount = $("#amount").val();
if (amount.search(/^\d*(?:\.\d{0,2})?$/) == -1) {
alert("金额格式不对，最多有两位小数");
return false;
}
2.密码采用数字、字母、特殊字符且长度为8-20位
function validatePwd(str) {
if (/^.*?[\d]+.*$/.test(str) && /^.*?[A-Za-z]/.test(str) && /^.*?[~/`!@#$%^&*()_+|{}?;:><\-\]\\[\/].*$/.test(str) && /^.{8,20}$/.test(str)) {
return true;
}
return false;
}3.验证电话号码
/**
* 验证电话号码
* @param phoneValue 要验证的电话号码
* @returns 匹配返回true 不匹配返回false
*/
function validatePhone(phoneValue) {
phoneValue = valueTrim(phoneValue);
var reg = /^[1][0-9]{10}$/;
return reg.test(phoneValue);
}4.判断是否是汉字
/**
* 判断是否是汉字
*
* @param charValue
* 要验证的数据
* @returns 匹配返回true 不匹配返回false
*/
function isCharacter(charValue) {
var reg = /^[\u4e00-\u9fa5]{0,}$/;
return reg.test(charValue);
}5.是否为字母:true:是，false:不是
function isChar(charValue){
var charPattern=/^[a-zA-Z]*$/; //是否为字母
result=charPattern.test(charValue);
return result;
}6.判断是否为数字
function isNum(numValue){
var numPattern=/^\d*$/; //数字的正则表达式
result=numPattern.test(numValue);
return result;
}7.整数的正则表达式
function isInt(intValue){
var intPattern=/^0$|^[1-9]\d*$/; //整数的正则表达式
result=intPattern.test(intValue);
return result;
}8.是否为字母和数字
function isCharNum(flagValue){
var flagPattern=/^[a-zA-Z0-9]*$/; //是否为字母和数字
result=flagPattern.test(flagValue);
return result;
}9.检验18位身份证号码
/**
* 检验18位身份证号码（15位号码可以只检测生日是否正确即可，自行解决）
*
* @param idCardValue
* 18位身份证号
* @returns 匹配返回true 不匹配返回false
*/
function idCardVildate(cid) {
var arrExp = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];// 加权因子
var arrValid = [1, 0, "X", 9, 8, 7, 6, 5, 4, 3, 2];// 校验码
var reg = /^[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)$/;
if (reg.test(cid)) {
var sum = 0, idx;
for (var i = 0; i < cid.length - 1; i++) {
// 对前17位数字与权值乘积求和
sum += parseInt(cid.substr(i, 1), 10) * arrExp[i];
}
// 计算模（固定算法）
idx = sum % 11;
// 检验第18为是否与校验码相等
return arrValid[idx] == cid.substr(17, 1).toUpperCase();
} else {
return false;
}
}10：js验证时间正则表达式
var reDateTime = /^(?:19|20)[0-9][0-9]-(?:(?:0[1-9])|(?:1[0-2]))-(?:(?:[0-2][1-9])|(?:[1-3][0-1])) (?:(?:[0-2][0-3])|(?:[0-1][0-9])):[0-5][0-9]:[0-5][0-9]$/;
var isDateTime = reDateTime.test('2012-01-31 09:00:22');
console.log(isDateTime);//true<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>脚本之家</title>
<script src="http://libs.baidu.com/jquery/1.9.0/jquery.js"></script>
<script>
$(document).ready(function () {
$('#ant').on('keyup mouseout input', function () {
var $this = $(this);
var v = $this.val();
/\S{5}/.test(v) && $this.val(v.replace(/\s/g, '').replace(/(.{4})/g, "$1 "));
});
})
</script>
</head>
<body>
<input type="text" id="ant" />
</body>
</html>結果：
轉自《Javascript 正则表达式实现为数字添加千位分隔符》
function formatNumber(num) {
if (!/^(\+|-)?(\d+)(\.\d+)?$/.test(num)) {
return num;
}
var a = RegExp.$1, b = RegExp.$2, c = RegExp.$3;
var re = new RegExp().compile("(\\d)(\\d{3})(,|$)");
while (re.test(b)) {
b = b.replace(re, "$1,$2$3");
}
return a + "" + b + "" + c;
}
var num = 1234567 / 3;
console.log("num=" + num + "，四舍五入：" + Math.round(num) + "，两位有效数字：" + num.toFixed(2) + "，添加千位分隔符：" + formatNumber(num)); 結果為：
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
