wangtao
/
fireInternet


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434
							<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js"><span id='RegExp'>/**
</span> * @class RegExp
 *
 * Creates a regular expression object for matching text according to a pattern.
 *
 * When using the constructor function, the normal string escape rules (preceding
 * special characters with \ when included in a string) are necessary. For
 * example, the following are equivalent:
 *
 *     var re = new RegExp(&quot;\\w+&quot;);
 *     var re = /\w+/;
 *
 * Notice that the parameters to the literal format do not use quotation marks to
 * indicate strings, while the parameters to the constructor function do use
 * quotation marks. So the following expressions create the same regular
 * expression:
 *
 *     /ab+c/i;
 *     new RegExp(&quot;ab+c&quot;, &quot;i&quot;);
 *
 * # Special characters in regular expressions
 *
 * |     Character    | Meaning
 * |:-----------------|:--------------------------------------------------------------------------------------
 * | `\`              | For characters that are usually treated literally, indicates that the next character
 * |                  | is special and not to be interpreted literally.
 * |                  | For example, `/b/` matches the character 'b'. By placing a backslash in front of b, that
 * |                  | is by using `/\b/`, the character becomes special to mean match a word boundary.
 * |                  |
 * |                  | _or_
 * |                  |
 * |                  | For characters that are usually treated specially, indicates that the next character is
 * |                  | not special and should be interpreted literally.
 * |                  |
 * |                  | For example, `*` is a special character that means 0 or more occurrences of the preceding
 * |                  | character should be matched; for example, `/a*\/` means match 0 or more &quot;a&quot;s. To match *
 * |                  | literally, precede it with a backslash; for example, `/a\*\/` matches 'a*'.
 * |                  |
 * | `^`              | Matches beginning of input. If the multiline flag is set to true, also matches
 * |                  | immediately after a line break character.
 * |                  |
 * |                  | For example, `/^A/` does not match the 'A' in &quot;an A&quot;, but does match the first 'A' in
 * |                  | &quot;An A&quot;.
 * |                  |
 * | `$`              | Matches end of input. If the multiline flag is set to true, also matches immediately
 * |                  | before a line break character.
 * |                  |
 * |                  | For example, `/t$/` does not match the 't' in &quot;eater&quot;, but does match it in &quot;eat&quot;.
 * |                  |
 * | `*`              | Matches the preceding item 0 or more times.
 * |                  |
 * |                  | For example, `/bo*\/` matches 'boooo' in &quot;A ghost booooed&quot; and 'b' in &quot;A bird warbled&quot;,
 * |                  | but nothing in &quot;A goat grunted&quot;.
 * |                  |
 * | `+`              | Matches the preceding item 1 or more times. Equivalent to `{1,}`.
 * |                  |
 * |                  | For example, `/a+/` matches the 'a' in &quot;candy&quot; and all the a's in &quot;caaaaaaandy&quot;.
 * |                  |
 * | `?`              | Matches the preceding item 0 or 1 time.
 * |                  |
 * |                  | For example, `/e?le?/` matches the 'el' in &quot;angel&quot; and the 'le' in &quot;angle.&quot;
 * |                  |
 * |                  | If used immediately after any of the quantifiers `*`, `+`, `?`, or `{}`, makes the quantifier
 * |                  | non-greedy (matching the minimum number of times), as opposed to the default, which is
 * |                  | greedy (matching the maximum number of times).
 * |                  |
 * |                  | Also used in lookahead assertions, described under `(?=)`, `(?!)`, and `(?:)` in this table.
 * |                  |
 * | `.`              | (The decimal point) matches any single character except the newline characters: \n \r
 * |                  | \u2028 or \u2029. (`[\s\S]` can be used to match any character including new lines.)
 * |                  |
 * |                  | For example, `/.n/` matches 'an' and 'on' in &quot;nay, an apple is on the tree&quot;, but not 'nay'.
 * |                  |
 * | `(x)`            | Matches `x` and remembers the match. These are called capturing parentheses.
 * |                  |
 * |                  | For example, `/(foo)/` matches and remembers 'foo' in &quot;foo bar.&quot; The matched substring can
 * |                  | be recalled from the resulting array's elements `[1], ..., [n]` or from the predefined RegExp
 * |                  | object's properties `$1, ..., $9`.
 * |                  |
 * | `(?:x)`          | Matches `x` but does not remember the match. These are called non-capturing parentheses.
 * |                  | The matched substring can not be recalled from the resulting array's elements `[1], ..., [n]`
 * |                  | or from the predefined RegExp object's properties `$1, ..., $9`.
 * |                  |
 * | `x(?=y)`         | Matches `x` only if `x` is followed by `y`. For example, `/Jack(?=Sprat)/` matches 'Jack' only if
 * |                  | it is followed by 'Sprat'. `/Jack(?=Sprat|Frost)/` matches 'Jack' only if it is followed by
 * |                  | 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.
 * |                  |
 * | `x(?!y)`         | Matches `x` only if `x` is not followed by `y`. For example, `/\d+(?!\.)/` matches a number only
 * |                  | if it is not followed by a decimal point.
 * |                  |
 * |                  | `/\d+(?!\.)/.exec(&quot;3.141&quot;)` matches 141 but not 3.141.
 * |                  |
 * | `x|y`            | Matches either `x` or `y`.
 * |                  |
 * |                  | For example, `/green|red/` matches 'green' in &quot;green apple&quot; and 'red' in &quot;red apple.&quot;
 * |                  |
 * | `{n}`            | Where `n` is a positive integer. Matches exactly n occurrences of the preceding item.
 * |                  |
 * |                  | For example, `/a{2}/` doesn't match the 'a' in &quot;candy,&quot; but it matches all of the a's
 * |                  | in &quot;caandy,&quot; and the first two a's in &quot;caaandy.&quot;
 * |                  |
 * | `{n,}`           | Where `n` is a positive integer. Matches at least n occurrences of the preceding item.
 * |                  |
 * |                  | For example, `/a{2,}/` doesn't match the 'a' in &quot;candy&quot;, but matches all of the a's in
 * |                  | &quot;caandy&quot; and in &quot;caaaaaaandy.&quot;
 * |                  |
 * | `{n,m}`          | Where `n` and `m` are positive integers. Matches at least `n` and at most `m` occurrences of the
 * |                  | preceding item.
 * |                  |
 * |                  | For example, `/a{1,3}/` matches nothing in &quot;cndy&quot;, the 'a' in &quot;candy,&quot; the first two a's
 * |                  | in &quot;caandy,&quot; and the first three a's in &quot;caaaaaaandy&quot;. Notice that when matching
 * |                  | &quot;caaaaaaandy&quot;, the match is &quot;aaa&quot;, even though the original string had more a's in it.
 * |                  |
 * | `[xyz]`          | A character set. Matches any one of the enclosed characters. You can specify a range of
 * |                  | characters by using a hyphen.
 * |                  |
 * |                  | For example, `[abcd]` is the same as `[a-d]`. They match the 'b' in &quot;brisket&quot; and the 'c'
 * |                  | in &quot;chop&quot;.
 * |                  |
 * | `[^xyz]`         | A negated or complemented character set. That is, it matches anything that is not
 * |                  | enclosed in the brackets. You can specify a range of characters by using a hyphen.
 * |                  |
 * |                  | For example, `[^abc]` is the same as `[^a-c]`. They initially match 'r' in &quot;brisket&quot; and
 * |                  | 'h' in &quot;chop.&quot;
 * |                  |
 * | `[\b]`           | Matches a backspace. (Not to be confused with `\b`.)
 * |                  |
 * | `\b`             | Matches a word boundary, such as a space. (Not to be confused with `[\b]`.)
 * |                  |
 * |                  | For example, `/\bn\w/` matches the 'no' in &quot;noonday&quot;; `/\wy\b/` matches the 'ly' in
 * |                  | &quot;possibly yesterday.&quot;
 * |                  |
 * | `\B`             | Matches a non-word boundary.
 * |                  |
 * |                  | For example, `/\w\Bn/` matches 'on' in &quot;noonday&quot;, and `/y\B\w/` matches 'ye' in &quot;possibly
 * |                  | yesterday.&quot;
 * |                  |
 * | `\cX`            | Where X is a letter from A - Z. Matches a control character in a string.
 * |                  |
 * |                  | For example, `/\cM/` matches control-M in a string.
 * |                  |
 * | `\d`             | Matches a digit character in the basic Latin alphabet. Equivalent to `[0-9]`.
 * |                  |
 * |                  | For example, `/\d/` or `/[0-9]/` matches '2' in &quot;B2 is the suite number.&quot;
 * |                  |
 * | `\D`             | Matches any non-digit character in the basic Latin alphabet. Equivalent to `[^0-9]`.
 * |                  |
 * |                  | For example, `/\D/` or `/[^0-9]/` matches 'B' in &quot;B2 is the suite number.
 * |                  |
 * | `\f`             | Matches a form-feed.
 * |                  |
 * | `\n`             | Matches a linefeed.
 * |                  |
 * | `\r`             | Matches a carriage return.
 * |                  |
 * | `\s`             | Matches a single white space character, including space, tab, form feed, line feed and
 * |                  | other unicode spaces. Equivalent to:
 * |                  |
 * |                  | `[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]`
 * |                  |
 * |                  | For example, `/\s\w*\/` matches ' bar' in &quot;foo bar.&quot;
 * |                  |
 * | `\S`             | Matches a single character other than white space. Equivalent to:
 * |                  |
 * |                  | `[^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]`
 * |                  |
 * |                  | For example, `/\S\w*\/` matches 'foo' in &quot;foo bar.&quot;
 * |                  |
 * | `\t`             | Matches a tab.
 * |                  |
 * | `\v`             | Matches a vertical tab.
 * |                  |
 * | `\w`             | Matches any alphanumeric character from the basic Latin alphabet, including the
 * |                  | underscore. Equivalent to `[A-Za-z0-9_]`.
 * |                  |
 * |                  | For example, `/\w/` matches 'a' in &quot;apple,&quot; '5' in &quot;$5.28,&quot; and '3' in &quot;3D.&quot;
 * |                  |
 * | `\W`             | Matches any character that is not a word character from the basic Latin alphabet. Equivalent
 * |                  | to `[^A-Za-z0-9_]`.
 * |                  |
 * |                  | For example, `/\W/` or `/[^A-Za-z0-9_]/` matches '%' in &quot;50%.&quot;
 * |                  |
 * | `\n`             | Where `n` is a positive integer. A back reference to the last substring matching the n
 * |                  | parenthetical in the regular expression (counting left parentheses).
 * |                  |
 * |                  | For example, `/apple(,)\sorange\1/` matches 'apple, orange,' in &quot;apple, orange, cherry,
 * |                  | peach.&quot; A more complete example follows this table.
 * |                  |
 * | `\0`             | Matches a NULL character. Do not follow this with another digit.
 * |                  |
 * | `\xhh`           | Matches the character with the code `hh` (two hexadecimal digits)
 * |                  |
 * | `\uhhhh`         | Matches the character with the Unicode value `hhhh` (four hexadecimal digits)
 *
 * The literal notation provides compilation of the regular expression when the expression is evaluated. Use
 * literal notation when the regular expression will remain constant. For example, if you use literal notation
 * to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.
 *
 * The constructor of the regular expression object, for example, new RegExp(&quot;ab+c&quot;), provides runtime
 * compilation of the regular expression. Use the constructor function when you know the regular expression
 * pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.
 *
 * &lt;div class=&quot;notice&quot;&gt;
 * Documentation for this class comes from &lt;a href=&quot;https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/RegExp&quot;&gt;MDN&lt;/a&gt;
 * and is available under &lt;a href=&quot;http://creativecommons.org/licenses/by-sa/2.0/&quot;&gt;Creative Commons: Attribution-Sharealike license&lt;/a&gt;.
 * &lt;/div&gt;
 */

<span id='RegExp-method-constructor'>/**
</span> * @method constructor
 * Creates new regular expression object.
 *
 * @param {String} pattern
 * The text of the regular expression.
 * @param {String} flags
 * If specified, flags can have any combination of the following values:
 *
 * - &quot;g&quot; - global match
 * - &quot;i&quot; - ignore case
 * - &quot;m&quot; - Treat beginning and end characters (^ and $) as working over multiple lines
 *   (i.e., match the beginning or end of _each_ line (delimited by \n or \r), not
 *   only the very beginning or end of the whole input string)
 */

//Methods

<span id='RegExp-method-exec'>/**
</span> * @method exec
 * Executes a search for a match in its string parameter.
 *
 * If the match succeeds, the `exec` method returns an array and updates properties of the regular
 * expression object. The returned array has the matched text as the first item, and then one item for
 * each capturing parenthesis that matched containing the text that was captured.  If the match fails,
 * the `exec` method returns `null`.
 *
 * If you are executing a match simply to find true or false, use the `test` method or the `String
 * search` method.
 *
 * Consider the following example:
 *
 *     // Match one d followed by one or more b's followed by one d
 *     // Remember matched b's and the following d
 *     // Ignore case
 *     var re = /d(b+)(d)/ig;
 *     var result = re.exec(&quot;cdbBdbsbz&quot;);
 *
 * The following table shows the results for this script:
 *
 * | Object           | Property/Index | Description                                                          | Example
 * |:-----------------|:---------------|:---------------------------------------------------------------------|:---------------------
 * | `result`         |                | The content of myArray.                                              | `[&quot;dbBd&quot;, &quot;bB&quot;, &quot;d&quot;]`
 * |                  | `index`        | The 0-based index of the match in the string                         | `1`
 * |                  | `input`        | The original string.                                                 | `cdbDdbsbz`
 * |                  | `[0]`          | The last matched characters.                                         | `dbBd`
 * |                  | `[1], ...[n]`  | The parenthesized substring matches, if any. The number of possible  | `[1] = bB`
 * |                  |                | parenthesized substrings is unlimited.                               | `[2] = d`
 * | `re`             | `lastIndex`    | The index at which to start the next match.                          | `5`
 * |                  | `ignoreCase`   | Indicates the &quot;`i`&quot; flag was used to ignore case.                    | `true`
 * |                  | `global`       | Indicates the &quot;`g`&quot; flag was used for a global match.                | `true`
 * |                  | `multiline`    | Indicates the &quot;`m`&quot; flag was used to search in strings across        | `false`
 * |                  |                | multiple lines.                                                      |
 * |                  | `source`       | The text of the pattern.                                             | d(b+)(d)
 *
 * If your regular expression uses the &quot;`g`&quot; flag, you can use the `exec` method multiple times to find
 * successive matches in the same string. When you do so, the search starts at the substring of `str`
 * specified by the regular expression's `lastIndex` property (`test` will also advance the `lastIndex`
 * property). For example, assume you have this script:
 *
 *     var myRe = /ab*\/g;
 *     var str = &quot;abbcdefabh&quot;;
 *     var myArray;
 *     while ((myArray = myRe.exec(str)) != null)
 *     {
 *         var msg = &quot;Found &quot; + myArray[0] + &quot;.  &quot;;
 *         msg += &quot;Next match starts at &quot; + myRe.lastIndex;
 *     print(msg);
 *     }
 *
 * This script displays the following text:
 *
 *     Found abb. Next match starts at 3
 *     Found ab. Next match starts at 9
 *
 * You can also use `exec()` without creating a RegExp object:
 *
 *     var matches = /(hello \S+)/.exec('This is a hello world!');
 *     alert(matches[1]);
 *
 * This will display an alert containing 'hello world!';
 *
 * @param {String} str The string against which to match the regular expression.
 * @return {Array} Array of results or `NULL`.
 */

<span id='RegExp-method-test'>/**
</span> * @method test
 * Tests for a match in its string parameter.
 *
 * When you want to know whether a pattern is found in a string use the test method (similar to the
 * `String.search` method); for more information (but slower execution) use the exec method (similar to
 * the `String.match` method). As with exec (or in combination with it), test called multiple times on
 * the same global regular expression instance will advance past the previous match.
 *
 * The following example prints a message which depends on the success of the test:
 *
 *     function testinput(re, str){
 *         if (re.test(str))
 *             midstring = &quot; contains &quot;;
 *         else
 *             midstring = &quot; does not contain &quot;;
 *         document.write (str + midstring + re.source);
 *     }
 *
 * @param {String} str The string against which to match the regular expression.
 * @return {Boolean} true if string contains any matches, otherwise returns false.
 */

<span id='RegExp-method-toString'>/**
</span> * @method toString
 * Returns a string representing the specified object. Overrides the `Object.prototype.toString`
 * method.
 *
 * The RegExp object overrides the `toString` method of the `Object` object; it does not inherit
 * `Object.toString`. For RegExp objects, the `toString` method returns a string representation of the
 * regular expression.
 *
 * The following example displays the string value of a RegExp object:
 *
 *     myExp = new RegExp(&quot;a+b+c&quot;);
 *     alert(myExp.toString());       // displays &quot;/a+b+c/&quot;
 *
 * @return {String} Regular expression as a string.
 */

//Properties

// Note that several of the RegExp properties have both long and short (Perl-like) names.
// Both names always refer to the same value. Perl is the programming language from which
// JavaScript modeled its regular expressions.

<span id='RegExp-property-global'>/**
</span> * @property {Boolean} global
 * Whether to test the regular expression against all possible matches in a
 * string, or only against the first.
 *
 * `global` is a property of an individual regular expression object.
 *
 * The value of `global` is true if the &quot;`g`&quot; flag was used; otherwise, `false`. The &quot;`g`&quot; flag
 * indicates that the regular expression should be tested against all possible matches in a string.
 *
 * You cannot change this property directly.
 */

<span id='RegExp-property-ignoreCase'>/**
</span> * @property {Boolean} ignoreCase
 * Whether to ignore case while attempting a match in a string.
 *
 * `ignoreCase` is a property of an individual regular expression object.
 *
 * The value of `ignoreCase` is true if the &quot;`i`&quot; flag was used; otherwise, false. The &quot;`i`&quot; flag indicates
 * that case should be ignored while attempting a match in a string.
 *
 * You cannot change this property directly.
 */

<span id='RegExp-property-lastIndex'>/**
</span> * @property {Number} lastIndex
 * The index at which to start the next match. A read/write integer property that specifies the index
 * at which to start the next match.
 *
 * `lastIndex` is a property of an individual regular expression object.
 *
 * This property is set only if the regular expression used the &quot;`g`&quot; flag to indicate a global search.
 * The following rules apply:
 *
 * -   If `lastIndex` is greater than the length of the string, `regexp.test` and `regexp.exec` fail,
 *     and `lastIndex` is set to 0.
 * -   If `lastIndex` is equal to the length of the string and if the regular expression matches the
 *     empty string, then the regular expression matches input starting at `lastIndex`.
 * -   If `lastIndex` is equal to the length of the string and if the regular expression does not match
 *     the empty string, then the regular expression mismatches input, and `lastIndex` is reset to 0.
 * -   Otherwise, `lastIndex` is set to the next position following the most recent match.
 *
 * For example, consider the following sequence of statements:
 *
 * -   `re = /(hi)?/g` Matches the empty string.
 * -   `re(&quot;hi&quot;)` Returns `[&quot;hi&quot;, &quot;hi&quot;]` with `lastIndex` equal to 2.
 * -   `re(&quot;hi&quot;)` Returns `[&quot;&quot;]`, an empty array whose zeroth element is the match string. In this
 *     case, the empty string because `lastIndex` was 2 (and still is 2) and &quot;`hi`&quot; has length 2.
 */

<span id='RegExp-property-multiline'>/**
</span> * @property {Boolean} multiline
 * Whether or not to search in strings across multiple lines.
 *
 * `multiline` is a property of an individual regular expression object..
 *
 * The value of `multiline` is true if the &quot;`m`&quot; flag was used; otherwise, `false`. The &quot;`m`&quot; flag
 * indicates that a multiline input string should be treated as multiple lines. For example, if &quot;`m`&quot;
 * is used, &quot;`^`&quot; and &quot;`$`&quot; change from matching at only the start or end of the entire string to the
 * start or end of any line within the string.
 *
 * You cannot change this property directly.
 */

<span id='RegExp-property-source'>/**
</span> * @property {String} source
 * The text of the pattern.
 *
 * A read-only property that contains the text of the pattern, excluding the forward slashes.
 *
 * `source` is a property of an individual regular expression object.
 *
 * You cannot change this property directly.
 */</pre>
</body>
</html>