In js, regular expressions are represented by a RegExp object. RegExp is the abbreviation of regular expression. RegExp simple pattern can be a single character. More complex patterns include more characters and can be used for parsing, format checking, substitution, etc. You can use a RegExp() constructor to create a RegExp object, or you can use the direct syntax
In js, a regular expression is represented by a RegExp object, and RegExp is the abbreviation of regular expression. RegExp simple pattern can be a single character. More complex patterns include more characters and can be used for parsing, format checking, substitution, etc. You can use a RegExp() constructor to create a RegExp object, or you can use literal syntax.
1. Introduction to RegExp.
RegExp is a regular expression (Regular Expression, often abbreviated as regex, regexp or RE/re/reg in code), which uses a single string to describe and match a series of rules that conform to a certain syntax String search mode, search mode can be used for text search and text replacement.
Regular expression is a search pattern formed by a sequence of characters. When you search for data in text, you can use the search pattern to describe the content you want to query. That is to say, regular expressions describe characters. The pattern object can be used to match string patterns and retrieve and replace them. It is a powerful tool for performing pattern matching on strings.
The so-called regular expression can be directly understood as a rule or pattern expression, which expresses a certain rule that a computer can understand, but is a text expression that is difficult for ordinary people to understand. It can be used for all text searches and The operation of text replacement is simply to process strings.
2. String method.
(1), charAt() Get a certain character and return a certain character in the string.
(2), split() Split the string and obtain an array.
(3), search()Find the position where a certain character first appears. It is better to use it with regular expressions. The return value is a numerical value. If not found, -1 is returned.
(4), match()Find the specified character in the string and return the character. If you do not use regular expressions, only the first occurrence of the specified character will be returned, and no further matching will be performed. If you use regular expressions and perform For global matching, all specified characters in the string are returned in the form of an array, or null is returned if not found.
(5), replace() Replace characters and return a new string. It is better used with regular expressions and can replace all matches.
<script>
var str='abcdefgca';
//返回字符串中某一位的字符。
alert(str.charAt()); //返回：d
//查找字符串首次出现的位置。
alert(str.search('z')); //返回：-
//查找指定的字符。
//只返回第一次出现的c，不再向后匹配。
alert(str.match('c')); //返回：c
//将'a'替换为'i'。
//只替换了第一个位置的a，不再向后匹配。
alert(str.replace('a', 'i')); //返回：ibcdefgca
//分割字符串。
var str='--aaa--cd';
var arr=str.split('-'); //返回：,,aaa,,cd
alert(arr);
</script>
Copy after login
Example: Use ordinary methods to find all the numbers in the string
Implementation idea: To find the characters The numbers in the string are actually not difficult. Use judgment to extract the numbers in the string first. Then there must be more than one number in the string, so an empty string is needed to store the extracted numeric characters, and then these The numeric characters are added to the array and finally returned, and that's it. Let’s take a look at how the program is implemented:
<script>
var str=' abc d aa c zz -=-=s-';
var arr=[];
var num='';
//首先循环遍历字符串
for(var i=;i<str.length;i++){
//再判断当前字符大于等于并且小于等于，则为数字
if(str.charAt(i)>='' && str.charAt(i)<=''){
//那么就将当前的字符存储在空字符串中
num += str.charAt(i);
}
else{
//如果字符串中有值。
if(num){
//将值添加到数组中。
arr.push(num);
//再清空字符串，避免重复添加。
num='';
}
}
}
//最后在整个字符串结束之后有可能还会有数字，再做一次判断。
if(num){
//如果还有值就添加到数组中。
arr.push(num);
//再清空字符串。
num='';
}
//返回：OK，现在返回就完成了。
alert(arr); //返回：,,,,,,,
</script>
Copy after login
Although it can be completed using ordinary methods and has a clear structure, the code is relatively long. If regular expressions are used, then a Expressions have done so much work and are very convenient. Let’s take a look at how to use regular expressions.
3. Use regular expressions.
Regular expression syntax: var re = new RegExp('pattern', 'modifier');
The pattern is the pattern of the expression, and the modifier is used to specify Global matching, case-insensitive, etc., the complete form is a regular expression.
Seeing that the regular syntax looks like this, isn’t it the typical syntax for newly created objects in JS? By the way, it means creating a new regular object. We all know that we should try to avoid using the new keyword. Using new will undoubtedly create a new object, which also means that it occupies a certain amount of memory space. If not handled properly, excessive accumulation will cause memory overflow, which is quite expensive. resources, which is not conducive to the implementation of code optimization. At the same time, this way of writing does not reflect the power of regularity. It should be very concise. Therefore, in actual use, this JS-style regular syntax is not used. Instead, another style is used, as follows ：
Syntax: var re = /mode/modifier;
This style is relatively concise and is an expression that most people cannot understand.
(1), modifier.
Modifiers are used to perform global matching and case sensitivity.
Ignore case: i (abbreviation of ignore, Chinese translation: ignore)
Global matching: g (abbreviation of global, Chinese translation: all/global)
Example: Global search for specified characters
<script>
var str='AbCdEFgiX';
//JS风格：
//这个正则表达式什么也不代表，只代表abc本身。
var reg=new RegExp('abc', 'i');
alert(str.match(reg)); //返回：AbC
//常用风格：
var re=/efg/i;
alert(str.match(re)); //返回：EFg
</script>
Copy after login
4, square brackets and metacharacters.
(1) Square brackets.
Square brackets are used to find characters within a certain range. ①. Any character Expression: [abc] Find any character in square brackets. [] here means or, that is, whichever one appears will do.
<script>
var str='apc xpc ppc bpc spc opc';
//[apx]pc，随便出现哪个都行，即：apc ppc xpc
var re=/[apx]pc/g;
alert(str.match(re)); //返回前个pc。
</script>
Copy after login
②、范围查找。
表达式：[0-9] [a-z] [A-z] [A-Z]
[0-9] 查找任意 0 - 9 的数字。
[a-z] 查找任意 a - z 的字符。
[A-z] 查找任意 大写A - 小写z 的字符。
[A-Z] 查找任意 大写A - 大写Z的字符。
③、排除查找。
表达式：[^abc] [^a-z] [^0-9]
[^abc] 查找任意不在方括号中的字符。
[^a-z] 查找任意除了字母以外的字符，包括数字符号中文外文。
[^0-9] 查找任意除了数字以外的字符，包括字母符号中文外文。
<script>
var str='ot out o.t o t o`t ot ot';
//o和t中间除了数字，什么都可以
var re=/o[^-]t/g;
alert(str.match(re)); //返回：out,o.t,o t,o`t
</script>
Copy after login
④、选择查找。
表达式：(a|b|c)
查找任何指定的选项，a或b或c。
⑤、匹配还可以使用组合模式，比如：[a-z0-9A-Z] [^a-z0-9]
[a-z0-9A-Z] 任意大小写字母和数字。
[^a-z0-9] 除了字母和数字以外，什么都可以。
(2)、元字符。
元字符是拥有特殊含义的字符，也可以叫做转义字符。
下面是一些常用的元字符：
Metacharacters
Description
Use
.
Find a single character, representing any character, excluding newlines and line terminators.
It is not recommended to use it because it is prone to problems.
\w
Find word characters, including English numbers and underscores, equivalent to [a-z0-9]
/\w/
\W
Find non Word characters, equivalent to [^a-z0-9]
/\W/
\d
Find a number, equivalent to [0-9]
##/\d/
\D
Find non-digits, equivalent to [^0-9]
/\D/
##\s
##Look for whitespace characters, including spaces, carriage returns, Tab, line feed, and form feed characters, and nonprintable characters cannot be displayed.
/\s/
\S
Find non White space characters.
/\S/
\b
Find words located in The beginning or end of the match, if no match is found, null is returned.
/\b/
\B
Find matches that are not word boundaries, that is, they are not located at the beginning or end. The type of the previous and next characters in the matching position is the same: that is, they must both be words,
or must Both are non-words. The beginning and end of the string are treated as non-word characters. If no match is found, null is returned.
/\B/
\n
Find newline character if Returns the location if found, or -1 if not found.
/\n/
##\f
Find page change symbol.
/\f/
\r
Find back Car talisman.
/\r/
##\t
Search system Symbol.
5. Quantifier.
The so-called quantifier is a quantifier, that is, a number. It is used in regular expressions to indicate the number of occurrences.
The following are some commonly used quantifiers:
Quantifier
Description
Use
*
Zero or any number of times, equivalent to {0,}
Not recommended , the range is too broad and not precise enough.
?
Zero or one time, equivalent to {0, 1}
/10?/g Performs a global search for 1, including zero or one '0' immediately following it.
##+
once or any number of times, equivalent to {1, }
/w+/g Perform a global search for at least one word.
{n}
exactly n times
/d {4}/g performs a global search for four-digit numbers.
{n,}
At least n times, no limit to
/d{3,}/g Perform a global search for numbers containing at least three digits.
{n, m}
At least n times, at most m times
/d{3,4}/g Perform a global search for numbers containing three or four digits.
The following are some commonly used matching patterns:
Mode
Description
Use
^a
Any character starting with a means the beginning of the line
/^\d/ Starting with a number /^a/g Global search for characters starting with 'a'
##a$
any A character ending in a represents the end of the line
/\d$/ Ends with a number /z$/g Global search for characters ending with 'z'
? =a
Any character followed by a
/a(?= b)/g Global search for 'a' followed by The characters of 'b'
?!a
Any characters that are not followed by a
/c(?= d)/g Global search for characters that do not follow 'd' after 'c'
6、字符串和正则配合。
(1)、search()配合正则
实例：找出字符串中第一次出现数字的位置
<script>
var str='asdf zxcvbnm';
//元字符\d，表示转义为数字
var re=/\d/;
alert(str.search(re)); //返回： 第一个数字为出现在第位
</script>
<script>
var str='asdf zxcvm';
//找出字符串中的数字可以使用元字符\d
var re=/\d/;
//没告诉系统要找多少数字，系统在找到数字后就返回
alert(str.match(re)); //返回：
//因此需要全局匹配，使用修饰符g
var re=/\d/g;
//没告诉系统要找几位，系统会将所有找到的数字返回
alert(str.match(re)); //返回：,,,,,,,,,,,,
//所以可以使用两个元字符，告诉系统要找的数字是位
var re=/\d\d/g;
//显然这样是不可取的，因为数字的位数并不固定，可能是位，有可能还是多位
alert(str.match(re)); //返回：,,,,
//所以需要用到量词+，+代表若干,也就是多少都可以。
var re=/\d+/g;
//现在返回正确。
alert(str.match(re)); //返回：,,,,
</script>
Copy after login
实例：使用正则找出字符串中所有数字
<script>
var str=' abc d aa c zz -=-=s-';
//alert(str.match(/\d+/g));
//元字符\d也可以使用[-]代替，到随便哪个都行。
alert(str.match(/[-]+/g)); //返回：,,,,,,,
</script>
Copy after login
正则是强大的字符串匹配工具，就这样简单的使用一句代码就完成了。
(3)、replace()配合正则
<script>
var str='abc zaaz deaxcaa';
//将字符串中的a替换为数字
alert(str.replace('a', )); //仅仅只将第一个a替换为
//配合正则使用匹配所有a再替换
var re=/a/g;
alert(str.replace(re, '')); //返回所有的a都为
</script>
调用 RegExp 对象 re 的 test() 方法，并为它传递字符串str，与这个表示式是等价的：(re.exec(str) != null)。
实例：搜索字符串是否含有指定的字符
<script>
var str='The best things in life are free, like hugs, smiles, friends, kisses, family, love and good memories.';
var re=/i/;
alert(re.test(str)); //返回：true
var reg=/z/;
alert(reg.test(str)); //返回：false
//上面的代码可以不用定义正则的变量，直接使用，将两行合并为一行。
alert(/i/.test(str));
alert(/z/.test(str));
</script>
<script>
var str = 'good good study day day up';
var re = /good/;
var arr = re.exec(str);
console.log(arr); //控制台显示：["good"]点开后显示： "good"，index ，input "good good study day day up"。
console.log(arr.index); //控制台显示：
console.log(arr.input); //控制台显示：good good study day day up
</script>
<script>
var str = 'good good study day day up';
var re = /g(o+)d/;
var arr = re.exec(str);
console.log(arr); //显示：["good", "oo"]点开后显示： "good", "oo", index ，input: "good good study day day up"
console.log(arr.length); //显示：
var reg = /(o+)/;
//var reg = /o+/; 只返回一个"oo"，长度为
var arr = reg.exec(str);
console.log(arr); //显示：["oo", "oo"]点开后显示： "oo", "oo", index ，input: "good good study day day up"
console.log(arr.length); //显示：
</script>
<script>
var str = 'good good study day day up';
var re = /good/g;
var arr;
do{
arr = re.exec(str);
console.log(arr);
console.log(re.lastIndex);
}
while(arr !== null)
/*
结果如下：
显示：["good"]，点开后： "good", index , input "good good study day day up"。
lastIndex为。
显示：["good"]，点开后： "good", index , input "good good study day day up"。
lastIndex为。
显示：null
lastIndex为。
*/
</script>
<script>
var str = 'good good study day day up';
var re = /good/g;
var arr;
while((arr = re.exec(str)) != null){
console.log(arr);
console.log(re.lastIndex);
}
/*
结果如下：
显示：["good"]，点开后： "good", index , input "good good study day day up"。
lastIndex为。
显示：["good"]，点开后： "good", index , input "good good study day day up"。
lastIndex为。
*/
</script>
<script>
var str = 'Today is a beautiful day, Day day happy！';
var re = /day/gi;
var str = str.replace(re, '天');
console.log(str); //输出：To天 is a beautiful 天, 天 天 happy！
reg = /(to)?day/gi;
reg.compile(reg);
str = str.replace(reg, '日');
console.log(str); //输出：日 is a beautiful 日, 日 日 happy！
</script>
这么说起来正则表达式貌似很简单的样子，其实挺难的，why are you so diao？归根结底就是这种一般人很难看懂的表达方式，自己当时写的时候很明白表达的是什么，过段时间回头，哎哟我去，怎么不认识了。其实这是一个熟能生巧的过程，记得有篇课文中写到“好记性不如烂笔头”，勤能补拙，多动手多写多思考，通过码海战术，反复推敲代码，让自己身经百战，见的多了，自然就不虚了，编程是一门艺术，精通任何一门艺术，都需要大量的练习和领悟，知识就是一个积累的过程，当然更重要的还是要自己去总结归纳，让知识真正属于自己。我觉着写程序这东西吧，最重要的还是思维，让代码始终跟着这种思维走，目的只有一个，怎么简单怎么省事怎么做，当然不是偷工减料，要明白需要什么，不需要什么，要呈现出什么样的效果，应该怎么去一步步实现，只要有这种实现目的的思维，就可以让代码始终保持着清晰简洁的状态，加快编写代码的效率，还有助于排错，也有利于代码的优化。那个好像扯太远了，每个人都有自己思考问题的方式，有不同的做事风格，只要最优化解决问题就好了，回到正事，接下来看看正则表达式应用的两个实例。
var someText= "web2.0 .net2.0" ;
var pattern=/(\\w+)(\\d)\\.(\\d)/g;
var outCome_exec=pattern.exec(someText); ["web2.0","web","2","0"]
var outCome_matc=someText.match(pattern); ["web2.0","net2.0"]
var patt1=new RegExp("e");
document.write(patt1.test("The best things in life are free"));
patt1.compile("d");
document.write(patt1.test("The best things in life are free"));
Copy after login
8、关于$0~$99的例子
JScript 代码
var str="alert.login.verifyfailed=Your email or password is incorrect!";
var reg=/^alert.\\w*(.\\w*)=((?:\\w*[ !\\.])*)$/;
var out=str.match(reg);
console.info($0);
Copy after login
9、测试RegExp属性
JScript 代码
function demo(){
var str = "abcdd abcsszabcdddccabAbcddABCEE";
var regex = /a(bc)/gi;
var t = null;
while(t = regex.exec(str)){
var result = "index = " + t.index + ", match = " + t[0] + ", group = " + t[1];
result += "/n$1=" + RegExp.$1 + ", lastMatch=" + RegExp.lastMatch + ", leftContext=" + RegExp.leftContext;
alert(result);
}
}
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
