Shulou(Shulou.com)06/01 Report--

This article mainly explains "what is the syntax of JavaScript object". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the syntax of JavaScript object".

Grammar

Text and construction symbols are possible:

/ pattern/flags new RegExp (pattern [, flags])

Parameters.

Pattern

The text of a regular expression

Flags

If specified, the flag can have any combination of the following values:

G

Global matching

I

Ignore case

M

Multiline; let the start and end characters (^ and $) work in multiline mode (for example, ^ and $can match the beginning and end of each line in the string (lines are split by\ n or\ r), not just at the beginning and end of the entire input string.

U

Unicode . Think of patterns as sequences of Unicode code points (code points).

Y

Viscosity; in the target string, match only from the display position specified by the lastIndex attribute of the regular expression (and do not attempt to match from any subsequent indexes).

Description

There are two ways to create a regular object: literals and constructors. To represent a string, the literal form does not use quotation marks, and arguments passed to the constructor use quotation marks. The following expression creates the same regular expression:

/ ab+c/i;new RegExp ('ab+c', 'i'); new RegExp (/ ab+c/, 'i')

The literal form provides the compilation state of the regular expression when the expression is assigned, and uses the literal quantity when the regular expression remains constant. For example, when you use literals to construct a regular expression in a loop, the regular expression is not recompiled (recompiled) at each iteration.

The constructor of the regular expression object, such as new RegExp ('ab+c'), provides regular expression runtime compilation (runtime compilation). If you know that the regular expression pattern will change, or if you don't know what pattern in advance, but get it from another source, such as user input, you can use the constructor.

Starting with ECMAScript 6, when the first parameter is a regular expression and the second flag parameter exists, new RegExp (/ ab+c/, 'i') no longer throws the exception of TypeError ("flags are not supported when constructed from other regular expressions"). Instead, a new regular expression is created with these parameters.

When using constructors to create regular objects, you need regular character escape rules (preceded by a backslash\). For example, the following is equivalent:

Var re = new RegExp ("\\ w+"); var re = /\ wicked /

Define regular expressions in terms of literals

Var expression = / pattern/ flags

The pattern part can be any simple or complex regular representation

Flage indicates the behavior of regular expressions 1.g: global mode, does not stop after the first match is found. 2.i: case insensitive mode 3.m: multiline mode

Example:

Var pattern1 = / at/g; / / matches all atvar pattern2 = / [bc] at/i; / / matches the first "bat" or "cat" in the string, not case-sensitive var pattern3 = / .at / gi; / / globally matches the three characters that end with .at. Case insensitive

All metacharacters used in the schema must be escaped. Metacharacters in regular expressions include: ([{\ ^ $|? * +.}])

Example:

Var pattern4 = /\ [bc\] at/i; / / matches the first "[bc] at" without case sensitivity

Using the RegExp constructor, take two arguments, parameter 1: string pattern to match, parameter 2: optional flag behavior

Example:

Var pattern5 = new RegExp ("[bc] at", "I")

Note: because the mode arguments of the RegExp constructor are strings, strings are double escaped in some cases. All metacharacters must be double escaped

Example:

Literal equivalent string

/\ [bc\] at/ "\ [bc\\] at"

/\ .at / "\\ .at"

/ name/\ age/ "name\ / age"

/\ d.\ d {1jurisdiction 2} / "\\ d.\ d {1pyrrine 2}"

/\ w\\ hello\\ 123 / "\\ w\ hello\ 123"

Note: creating regular expressions using literals is not the same as instantiating, literals always share the same RegExp instance (ECMAScript3). Each new RegExp instance created using the constructor is a new instance.

RegExp instance Properties

Console.log (pattern5.global); / / whether the g flag console.log (pattern5.ignoreCase) is set for false; / / whether the I flag console.log (pattern5.multiline) is set for true; / / whether the m flag console.log (pattern5.lastIndex) is set for false; / / 0 to start searching for the starting position of the next match console.log (pattern5.source); / / [bc] the string representation of at regular expression

Inherit attribute

Console.log (pattern5.toString ()); / / [bc] the literal quantity of the at/i regular expression represents console.log (pattern5.toLocaleString ()); / / [bc] the literal quantity of the at/i regular expression represents console.log (pattern5.valueOf ()); / / [bc] the literal quantity of the at/i regular expression

RegExp instance method

Method 1: exec (), which accepts a parameter that applies the pattern string. Returns an array containing the information of the first match, or null if none, and an instance of the array containing two properties, index (the position of the match in the character) and input (the string that applies the regular).

Var text = "huang jin liang shi ge hao ren"; var pattern6 = new RegExp ("huang (jin liAng (shi ge hao ren)?)?", "I"); var matches = pattern6.exec (text); console.log (matches); / / ['huang jin liang shi ge hao ren',//' jin liang shi ge hao ren',// 'shi ge hao ren',// index: 0 matches / input:' huang jin liang shi ge hao ren'] var text1 = "cat, bat, sat" Var pattern7 = new RegExp (".at") var matches1 = pattern7.exec (text1); console.log (matches1); / / catvar pattern8 = new RegExp (".at", "gm"); var matches2 = pattern8.exec (text1); console.log (matches2); / / catvar matches3 = pattern8.exec (text1); console.log (matches3); / / batvar matches4 = pattern8.exec (text1); console.log (matches4); / / satvar matches5 = pattern8.exec (text1); console.log (matches5); / / null

Method 2: test (), which accepts a parameter that applies the pattern string. Returns true if the pattern matches this parameter, and vice versa false

Var text2 = "0000-00"; var pattern9 = new RegExp ("\\ d {3} -\ d {2} -\ d {4}"); console.log (pattern9.test (text2)) console.log (text2); if (pattern9.test (text2)) {console.log ("match success");} else {console.log ("match failure");}

Constructor properties (not supported by some browsers)

Long attribute name short attribute name description

Input $_ the last string to match

LastMatch $& the last match

LastParen $+ last capture group

The text before lastMatch in the leftContext $`input string

Multiline $* Boolean, whether it is in multiline mode

The text after lastMatch in the rightContext $'input string

$1 capture 9 is used to store which capture group

Limitations in ECMAScript

1. \ An and\ Z anchors that match the beginning and end of the string

two。 Look backwards

3. Union and intersection classes

4. Atomic group

5.Unicode support (except for single characters)

6. Name the capture group

7.s and x matching patterns

8. Condition matching

9. Regular expression comment

Just found a way to match multiple lines in js

Var s = "Please yes\ nmake my day!"; alert (s.match (/ yes.*day/)); / / Returns nullalert (s.match (/ yes [^] * day/)); / / Returns' yes\ nmake my day'

Unfortunately, editplus can not be used, most of the time it is more convenient to use dw.

Thank you for your reading, these are the contents of "what does JavaScript object Grammar have". After the study of this article, I believe you have a deeper understanding of what JavaScript object Grammar has, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.