The following is a brief discussion on the use of RegExp objects and brackets in JS regular expressions. The content is quite good, so I will share it with you now and give it as a reference.
Creation of RegExp objects:
Conventional regular expressions can be created with direct quantities, that is, characters enclosed by slashes "/" . But in an environment that requires parameter changes, the RegExp() constructor is a better choice:
var reg1 = /'\w '/g;
var reg2 = new RegExp(' \'\\w \'','g');
Comparing the two creation methods, the first parameter in RegExp is the regular string to be created. On the one hand, pay attention, because it is not The representation of a direct quantity, so there is no need to enclose it with slashes "/"; instead, the quotation marks "'" and the escape symbol "\" must be escaped twice in the string.
In addition, whether it is a direct variable or the RegExp() constructor, a new RegExp object is generated and assigned to a variable.
Similarities and differences between match() and exec():
match and exec are common methods for matching strings with regular expressions. The functions implemented by the two are similar, with some subtle differences:
1. Usage
match is a method of string packaging objects, usage ：String.match(RegExp);
exec is a method of regular expression object, usage: RegExp.exec(String);
2. Returned result
When RegExp does not set the global flag "g":
The return results of both are the same. That is, null is returned when there is no matching value, and an array (let array) is returned when there is a matching value. array[0] is the matched string, array[1], array[2]... correspond to the substrings $1, $2... matched by parentheses in the regular expression. At the same time, the array has two attributes, array.index represents the initial position of the matching string, and array.input represents the string being retrieved.
When RegExp has the global flag "g" set:
match returns an array array when there is a value. Each item in the array represents all the matched strings in turn, so there are no more substrings matched by parentheses. At this time, the array has no index attribute and input attribute.
exec behaves the same as without the global flag "g". What is returned at this time is an array array, array[0] is the currently matched string, array[1], array[2]...are the strings matched by the parentheses under the current match. At this time, pay attention to the lastIndex attribute of the RegExp object, which represents the position after the end of the matched string in the original string. When there are no further matching results, the lastIndex attribute is set to 0. Therefore, you can use the lastIndex loop to find all matching strings.
Support multiple matching methods:
js code
var testStr = "now test001 test002";
var re = /test(\d+)/ig;
var r = "";
while(r = re.exec(testStr)) {
alert(r[0] + " " + r[1]);
}In addition, you can also use testStr.match(re), but in this case, you cannot have the g option, and you can only get the first match.
1. Regular expression rules
1.1 Ordinary characters
Letters, numbers, Chinese characters, underscores, and punctuation marks not specifically defined in the following chapters are all "ordinary characters". Ordinary characters in an expression, when matching a string, match the same character.
Example 1: When the expression "c" matches the string "abcde", the matching result is: success; the matched content is: "c"; the matched position is: starting at 2, Ended at 3. (Note: Whether the subscript starts from 0 or 1 may differ depending on the current programming language)
Example 2: The expression "bcd", when matching the string "abcde", the matching result is : Success; the matched content is: "bcd"; the matched position is: starting at 1 and ending at 4.
1.2 Simple escape characters
For some characters that are inconvenient to write, use the method of adding "/" in front. In fact, we are all familiar with these characters.
Expression | can match |
/r, /n | represents carriage return and line feed characters |
/t | Tab character |
// | represents "/" itself |
There are other punctuation marks that have special uses in later chapters. Adding "/" in front of them represents the symbol itself. For example: ^ and $ have special meanings. If you want to match the "^" and "$" characters in the string, the expression needs to be written as "/^" and "/$".
Expression | can match |
/^ | Matches the ^ symbol itself |
/$ | ##Match the $ symbol itself |
| ##Match the decimal point (.) itself |
1.3 Expressions that can match 'multiple characters'
Some expression methods in regular expressions can match any one of 'multiple characters' character. For example, the expression "/d" can match any number. Although it can match any of the characters, it can only be one, not multiple. This is like playing poker. The king and king can replace any card, but they can only replace one card.
| can match | |
| Any number, any one from 0 to 9 | |
| Any letter, number or underscore, that is, any one of A~Z,a~z,0~9,_ | |
##Including any one of the whitespace characters such as spaces, tabs, form feeds, etc. | . |
The decimal point can match any character except the newline character (/n) | Example 1: When the expression "/d/d" matches "abc123", the matching result is: success; the matched content is: "12"; the matched position is: starting at 3 and ending at 5. |
Use square brackets [ ] to include a series of characters that can match any one of them. Use [^] to include a series of characters to match any character except those characters. In the same way, although any one of them can be matched, it can only be one, not multiple.
can match | [ab5@] | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Match "a" or "b" or "5" or "@" | [^abc] | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Matches any character except "a", "b", "c" | [f-k] | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| ##Match any letter between "f"~"k" | [^A-F0-3] | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Example 1: When the expression "[bcd][bcd]" matches "abc123", the matching result is: success; the matched content is: "bc"; the matched position is: starting at 1, ending At 3. Example 2: When the expression "[^abc]" matches "abc123", the matching result is: success; the matched content is: "1"; the matched position is: starting at 3, Ended at 4. 1.5 Special symbols that modify the number of matches The expressions mentioned in the previous chapter, whether they can only match one type of character, or can match multiple An expression containing any one of these characters can only be matched once. If you use an expression plus a special symbol that modifies the number of matches, you can match repeatedly without writing the expression again. The usage method is: put the "number of times modification" after the "modified expression". For example: "[bcd][bcd]" can be written as "[bcd]{2}".
Example 2: When the expression "go{2,8}gle" matches "Ads by goooooogle", the matching result is: success; the matched content is: "goooooogle"; the matched position Yes: starts at 7 and ends at 17. 1.6 Some other special symbols representing abstract meaningsSome symbols represent abstract special meanings in expressions:
Example 5: Expression "Tom|Jack " When matching the string "I'm Tom, he is Jack", the matching result is: success; the matched content is: "Tom"; the matched position is: starting at 4 and ending at 7. When matching the next one, the matching result is: success; the matched content is: "Jack"; the matched position: starts at 15 and ends at 19. Example 6: When the expression "(go/s*) " matches "Let's go go go!", the matching result is: success; the matched content is: "go go go"; the matched The positions are: starts at 6 and ends at 14. Example 7: When the expression "￥(/d /.?/d*)" matches "＄10.9,￥20.5", the matching result is: success; the matched content is: "￥ 20.5"; the matched position is: starting at 6 and ending at 10. The content matched by obtaining the bracket range alone is: "20.5". 2. Some advanced rules in regular expressions 2.1 Greedy and non-greedy in the number of matches When using special symbols that modify the number of matches, there are several expression methods that can make the same expression match different times, such as: "{m,n}", "{m,}", " ?", "*", " ", the specific number of matches depends on the matched string. This kind of repeated matching expression an indefinite number of times always matches as many times as possible during the matching process. For example, for the text "dxxxdxxxd", the example is as follows:
It can be seen that "/w" always matches as many characters as possible that match its rules when matching. Although in the second example, it does not match the last "d", that is so that the entire expression can be matched successfully. In the same way, expressions with "*" and "{m,n}" are matched as much as possible, and expressions with "?" are also "matched" as much as possible when they can be matched or not. This matching principle is called the "greedy" mode. Non-greedy mode: Add a "?" sign after the special symbol that modifies the number of matches to make the expression with an indefinite number of matches as possible as possible Fewer matches, so that expressions that can match or not match can be "unmatched" as much as possible. This matching principle is called "non-greedy" mode, also called "reluctant" mode. If there are fewer matches, the entire expression will fail to match. Similar to the greedy mode, the non-greedy mode will minimally match more to make the entire expression match successfully. For example, for the text "dxxxdxxxd":
3.4 Subexpressions within brackets "( )" if you want the matching result to be different To record for later use, you can use the "(?:xxxxx)" format Example 1: When the expression "(?:(/w)/1)" matches "a bbccdd efg", The result is "bbccdd". Matches within the bracket "(?:)" range are not logged, so "(/w)" is quoted using "/1". 3.5 Introduction to commonly used expression attribute settings: Ignorecase, Singleline, Multiline, Global
4. Other tips 4.1 If you want to know about the complex regular syntax that the advanced regular engine supports, please refer to the DEELX regular engine on this site Documentation. 4.2 If you want the expression to match the entire string instead of finding a part of the string, you can use "^" and "$" at the beginning and end of the expression, for example: "^ /d $" requires the entire string to be digits only. 4.3 If the matched content is a complete word, not a part of the word, then use "/b" at the beginning and end of the expression, for example: use "/b(if|while|else| void|int……)/b" to match keywords in the program. 4.4 The expression should not match the empty string. Otherwise, you will always get matching success, but nothing will be matched as a result. For example: when preparing to write an expression matching "123", "123.", "123.5", ".5", the integer, decimal point, and decimal digits can be omitted, but do not write the expression as: " /d*/.?/d*", because this expression can also match successfully if there is nothing. A better way to write it is: "/d /.?/d*|/./d ". 4.5 Do not loop infinitely for submatches that can match the empty string. If each part of the subexpression within the brackets can be matched 0 times, and the brackets as a whole can be matched an unlimited number of times, then the situation may be more serious than the previous item, and the matching process may loop endlessly. Although some regular expression engines have adopted methods to avoid this situation, such as .NET regular expressions, we should still try to avoid this situation. If we encounter an infinite loop when writing an expression, we can also start from this point to find out whether it is the reason mentioned in this article. 4.6 Reasonably choose greedy mode and non-greedy mode, see topic discussion. 4.7 Or the left and right sides of "|", it is best to match only one side of a certain character, so that the expressions on both sides of "|" will not be different due to the exchange of positions. Next----------------------------------- ----------- 1, define regular expression 1) definition There are two forms of regular expressions, one is the ordinary way and the other is the constructor way. 2) Ordinary method: var reg=/expression/additional parameters Expression: a string representing a certain rule, in which certain special characters can be used to represent special The rules will be explained in detail later. Additional parameters: used to expand the meaning of the expression. Currently there are three main parameters: The above three parameters can be combined in any combination to represent a compound meaning. Of course, no parameters can be added. Example: 3) Constructor method: var reg=new RegExp( "Expression", "Additional parameters"); 4) Normal way The difference from the constructor method 2, expression mode 1) Expression mode refers to the expression method and style of expression, that is, how to describe the "expression" in var reg=/expression/additional parameters? 4) Compound pattern: refers to a pattern expressed by wildcard characters, for example: 5) Explanation of special characters in compound mode: 1>/: used as an escape character in many programming languages. Generally speaking, if the 2>^：匹配输入字符串的起始端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符后匹配。 例子2： 中的第一行第一个B，第三行中的第一个B 与^的用法相反。 例子：/t$/匹配“bat”中的t，但是不匹配“hate”中的t 例子2：/t$/匹配 “tag at 4>*：匹配前一个字符0次或多次。 例子：/ab*/匹配“dddabbbbc”中的“abbbb”，也匹配“ddda”中的“a” 5>+：匹配前一个字符1次或多次。 例子：/ab+/匹配“dddabbbbc”中的“abbbb”，但不匹配“ddda” 与后面的{1,}（原型：{n,}）的用法类似 6>?：?的用法比较特殊，一般来说它用来对前一个字符做0次或1次匹配，但是它有另外两种特殊的用法： 如果紧跟在*、+、?和{ }之后，则表示原始匹配的最小次数匹配，例如： 7>.：小数点中的“.”号，匹配任何一个单独的字符，但是换行符除外。 标准中总共有哪些字符？请参考：字符集 8>(x)：表示匹配x(并非特指字符x或者特指一个字符，x表示一个字符串)，而且匹配会被记住，在语法中这种()被称为“capturing parentheses ”，即捕捉用的小括号。 匹配会被记住，是因为在表达式提供的函数中，有些函数返回一个数组，该数组会保存所匹配的所有字符串，例如exec()函数。 例子1： var regx=/a(b)c/; var rs=regx.exec(“abcddd”); Copy after login 从上面可以看出,/a(b)c/匹配“abcddd”中的“abc”，因为()的原因，b也会记录下来，因此rs返回的数字内容为： 例子2： var regx=/a(b)c/; var rs=regx.exec(“acbcddd”); Copy after login rs返回null，因为/a(b)c/不匹配“acbcddd”，所以()中的b不会被记录下来（尽管字符串中含有b） 9>(?:x)：匹配x，但不会记住x，这种格式中的()被称为“non-capturing parentheses ”，即非捕捉用的小括号。 例子： var regx=/a(?:b)c/; var rs=regx.exec(“abcddd”); Copy after login 从上面可以看出,/a(?:b)c/匹配“abcddd”中的“abc”，因为(?:)的原因，b不会记录下来，因此rs返回的数字内容为： 10>X(?=y)：匹配x，仅当后面紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。 例子： var regx=/user(?=name)/; var rs=regx.exec(“The username is Mary”); Copy after login 结果：匹配成功，而且rs的值为{user} 11>X(?!y)：匹配x，仅当后面不紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。 例子： var regx=/user(?!name)/; var rs=regx.exec(“The user name is Mary”); Copy after login 结果：匹配成功，而且rs的值为{user} 例子2： var regx=//d+(?!/.)/; var rs=regx.exec(“54.235”); Copy after login 结果：匹配成果，rs的值为{5}，不匹配54是因为54后面跟着“.”号，当然235也匹配，但是由于exec方法的行为，235不会被返回 12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。 例子： var regx=/beijing|shanghai/; var rs=regx.exec(“I love beijing and shanghai”); Copy after login 结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。 13>{n}：匹配前一个字符的n次出现。 例子： var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);Copy after login 结果：匹配成功，rs的值为：{abbc}。 14>{n,}：匹配前一个字符的至少n次出现。 例子： var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);Copy after login 结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。 15>{n,m}：匹配前一个字符的至少n次最多m次的出现。 例子： var regx=/ab{2,5}c/;
var rs=regx.exec(“abbbcd”);Copy after login 结果：匹配成功，rs的值为：{abbbc}。 例子2： var regx=/ab{2,2}c/;
var rs=regx.exec(“abbcd”);Copy after login 结果：匹配成功，rs的值为：{abbc}。 例子3： var regx=/ab(2,5)/; var rs=regx.exec(“abbbbbbbbbb”); Copy after login 结果：匹配成功，rs的值为：{abbbbb}，这说明，如果前一个字符出现多于m次，则只匹配m次。另外： 16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[x-z]。 例子： var regx=/a[bc]d/; var rs=regx.exec(“abddgg”); Copy after login 结果：匹配成功，rs的值为：{abd} 例子2： var regx=/a[bc]d/; var rs=regx.exec(“abcd”); Copy after login 结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。 17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^x-z]。 例子： var regx=/a[^bc]d/; var rs=regx.exec(“afddgg”); Copy after login 结果：匹配成功，rs的值为：{afd} 例子2： var regx=/a[^bc]d/; var rs=regx.exec(“abd”); Copy after login 结果：匹配失败，rs的值为：。 18>[/b]：匹配退格键。 19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。 例子： var regx=//bc./; var rs=regx.exec(“Beijing is a beautiful city”); Copy after login 结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。 20>/B：代表一个非单词边界。 例子： var regx=//Bi./; var rs=regx.exec(“Beijing is a beautiful city”); Copy after login 结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。 21>/cX，匹配一个控制字符。例如， /cM 匹配一个 Control-M 或 21>/d：匹配一个数字字符，等同于[0-9]。 例子： var regx=/user/d/; var rs=regx.exec(“user1”); Copy after login 结果：匹配成功，rs的值为：{user1} 22>/D：匹配一个非数字字符，等同于[^0-9]。 var regx=/user/D/; var rs=regx.exec(“userA”); Copy after login 结果：匹配成功，rs的值为：{userA} 23>/f：匹配一个换页符。 24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。 var regx=/a/nbc/m; var str=“a bc”; var rs=regx.exec(str); Copy after login 结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。 26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029]. 例子： var regx=//si/; var rs=regx.exec(“Beijing is a city”); Copy after login 结果：匹配成功，rs的值为：{ i} 27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029]. 例子： var regx=//Si/; var rs=regx.exec(“Beijing is a city”); Copy after login 结果：匹配成功，rs的值为：{ei} 28>/t：匹配一个tab 例子： var regx=/a/tb/; var rs=regx.exec(“a bc”); Copy after login 结果：匹配成功，rs的值为： {a bc} 29>/v：匹配一个竖向的tab 30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。 例子： var regx=//w/; var rs=regx.exec(“$25.23”); Copy after login Copy after login 结果：匹配成功，rs的值为：{2} 31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。 例子： var regx=//w/; var rs=regx.exec(“$25.23”); Copy after login Copy after login 结果：匹配成功，rs的值为：{$} 32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。 例子： var regx=/user([,-])group/1role/; var rs=regx.exec(“user-group-role”); Copy after login 结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。 33>/0：匹配一个NUL字符。 34>/xhh：匹配一个由两位16进制数字所表达的字符。 35>/uhhhh：匹配一个由四位16进制数字所表达的字符。 3，表达式操作 1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。 1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如： var regx=//d+/; var rs=regx.exec(“3432ddf53”); Copy after login 返回的rs值为：{3432} var regx2=new RegExp(“ab(/d+)c”); var rs2=regx2.exec(“ab234c44”); Copy after login 返回的rs值为：{ab234c,234} var regx=/user/d/g; var rs=regx.exec(“ddduser1dsfuser2dd”); var rs1=regx.exec(“ddduser1dsfuser2dd”); Copy after login 则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。 2>test(str)，判断字符串str是否匹配表达式，返回一个布尔值。例如： var regx=/user/d+/g; var flag=regx.test(“user12dd”); Copy after login flag的值为true。 3）String对象方法 1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配 var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.match(regx); Copy after login rs的值为：{user1,user3} 2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。 var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.search(regx); Copy after login rs的值为：0 3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。 var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”00”); Copy after login rs的值为：003userddd0045 var regx=/u(se)r/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”$1”); Copy after login rs的值为：se3userdddse45 var regx=“user” var str=“user13userddduser345”; var rs=str.replace(regx,”00”); Copy after login rs的值为： 0013userddduser345 4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。 var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.split(regx); Copy after login rs的值为：{3userddd,45} 4，表达式相关属性 1）表达式相关属性，是指和表达式相关的属性，如下面的形式： var regx=/myexpr/; var rs=regx.exec(str); Copy after login 其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。 1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex1=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex2=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex3=regx.lastIndex; Copy after login 上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。 2>source，返回表达式字符串自身。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var source=regx.source; Copy after login source的值为user/d 1>index，返回当前匹配的位置。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var index1=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index2=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index3=rs.index; Copy after login index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。 2>input，用于匹配的字符串。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var input=rs.input; Copy after login input的值为sdsfuser1dfsfuser2。 3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var value1=rs[0]; rs=regx.exec(“sdsfuser1dfsfuser2”); var value2=rs[0]; Copy after login value1的值为user1,value2的值为user2 5，实际应用 1）实际应用一 <script>
function checkForm(obj){
var username=obj.username.value;
var regx=/^[/u4e00-/u9fa5]{2,4}$/g
if(!regx.test(username)){
alert(“Invalid username!”);
return false;
}
return true;
}
</script>
<form name=“myForm”onSubmit=“return checkForm(this)”>
<input type=“text” name=“username”/>
<input type=“submit” vlaue=“submit”/>
</form>Copy after login 2）实际应用二 描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。 实现： <script>
function toPlainText(htmlStr){
var regx=/<[^>]*>|<//[^>]*>/gm;
var str=htmlStr.replace(regx,"");
return str;
}
</script>
<form name=“myForm”>
<textarea id=“htmlInput”></textarea>
<input type=“button” value=“submit” onclick=“toPlainText(document.getElementById(‘htmlInput').value”/>
</form>Copy after login 三，小结 1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。 2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！ 总结1：附件参数g的用法 表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述： 1）对于表达式对象的exec方法，不加入g，则只返回第一个匹配，无论执行多少次均是如此，如果加入g，则第一次执行也返回第一个匹配，再执行返回第二个匹配，依次类推。例如 var regx=/user/d/;
var str=“user18dsdfuser2dsfsd”;
var rs=regx.exec(str);//此时rs的值为{user1}
var rs2=regx.exec(str);//此时rs的值依然为{user1}Copy after login 如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2} 通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。 2）对于表达式对象的test方法，加入g于不加上g没有什么区别。 3）对于String对象的match方法，不加入g，也只是返回第一个匹配，一直执行match方法也总是返回第一个匹配，加入g，则一次返回所有的匹配（注意这与表达式对象的exec方法不同，对于exec而言，表达式即使加上了g，也不会一次返回所有的匹配）。例如： var regx=/user/d/;
var str=“user1sdfsffuser2dfsdf”;
var rs=str.match(regx);//此时rs的值为{user1}
var rs2=str.match(regx);//此时rs的值依然为{user1}Copy after login 如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2} 4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点） 5）对于String对象的split方法，加上g与不加g是一样的，即： var sep=/user/d/; var array=“user1dfsfuser2dfsf”.split(sep); Copy after login 则array的值为{dfsf, dfsf} 此时sep=/user/d/g，返回值是一样的。 6）对于String对象的search方法，加不加g也是一样的。 总结2：附加参数m的用法 附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点 1）使用^的例子 var regx=/^b./g;
var str=“bd76 dfsdf
sdfsdfs dffs
b76dsf sdfsdf”;
var rs=str.match(regx);Copy after login 此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配 2）使用其他模式的例子，例如 var regx=/user/d/;
var str=“sdfsfsdfsdf
sdfsuser3 dffs
b76dsf user6”;
var rs=str.match(regx);Copy after login 此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。 3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子 var regx=/^b./;
var str=“ret76 dfsdf
bjfsdfs dffs
b76dsf sdfsdf”;
var rs=str.match(regx);Copy after login 此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回） 总结3： 在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子： var regx=/a/r/nbc/;
var str=“a
bc”;
var rs=regx.exec(str);Copy after login 结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。 以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！ 相关推荐： The above is the detailed content of About the use of RegExp objects and brackets in JS regular expressions. For more information, please follow other related articles on the PHP Chinese website!
Related labels：
source：php.cn
Previous article：About react-native’s ART drawing method
Next article：2 ways to connect node.js to MongoDB database
Statement of this Website
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
Latest Articles by Author
Latest Issues
Regular expression to match words
I have a script where I am trying to match new job names with existing job names in a data...
From 2024-04-06 21:24:04
0
1
606
Related Topics
More>
Popular Recommendations
Popular Tutorials
More>
Latest Downloads
More>
|
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
