以下の説明では、次の変数を用いる:

• Input は、正規表現パターンによりマッチされている文字列である。表記 input[n] は input の n 番目の文字を意味する。 n の範囲は 0 から InputLength -1 までである。
• InputLength は、 Input 文字列の文字数である。
• NCapturingParens は、パターン内の左捕捉括弧の数の総数 (すなわち Atom :: ( Disjunction ) 生成規則が展開される回数の総数) である。左捕捉括弧は、 Atom :: ( Disjunction ) 生成規則の ( 終端記号によりマッチされる、任意の ( パターン文字である。
• IgnoreCase は、 RegExp オブジェクトの ignoreCase プロパティの設定である。
• Multiline は、 RegExp オブジェクトの multiline プロパティの設定である。

さらに、以下の説明では、次の内部データ構造を用いる:

• CharSet は、文字の数学的集合である。
• State は (endIndex, captures) のペアの並びで、 endIndex を整数、 captures を NCapturingParens 値の内部配列とする。 State は、正規表現のマッチングアルゴリズムにおいて部分マッチの状態を表すのに使用される。 endIndex は、その時点でパターンにマッチする最後の入力文字のインデックス + 1 であり、 captures は捕捉括弧の結果を保持する。 captures の n 番目の要素は、捕捉括弧の n 番目の集合によって取得される値を表す文字列であり、捕捉括弧の n 番目の集合がまだ届いていないならば undefined である。バックトラッキングのため、多くの state がマッチング処理間いつでも使用されてよい。
• MatchResult は、 State であるか、またはマッチに失敗したことを示す特殊トークン failure であり、どちらか一方である。
• Continuation 関数は、内部クロージャ (すなわち、引数が既に値に結合されている内部関数) であり、 1 個の引数 State をとり結果 MatchResult を返す。内部クロージャが、そのクロージャを生成する関数に結合された変数を参照するならば、クロージャが使用するのはクロージャが生成されたときにそれらの変数が持っていた値である。 continuation は、引数 State で与えられる中間状態で開始して、入力文字列に対するパターンの残りの部分 (クロージャの結合済み引数で特定される) にマッチを試みる。マッチに成功したならば、 continuation はそれに達した最後の State を返す; match に失敗ならば、 continuation は failure を返す。
• Matcher 関数は、 2 個の引数 -- State と Continuation -- をとる内部クロージャで、結果 MutchResult を返す。 matcher は、引数 State で与えられる中間状態から開始して、入力文字列に対してパターンの中央の部分パターン (クロージャの結合済み引数で特定される) にマッチを試みる。引数 Continuation は、パターンの残りにマッチさせるクロージャでなければならない。新しい State を得るためのパターンの部分パターンのマッチングの後、 matcher はその状態の上に Cantinuation を呼出し、パターンの残りがうまくマッチできるかテストする。マッチできるならば matcher は continuation に返された状態を返す; できないならば matcher は、成功するか、または全ての可能性をつかい尽くすまで、 Continuation を繰返し呼出し、その選択点で異なる選択を試してよい。
• AssertionTester 関数は、引数 State をとる内部クロージャで、結果 boolean を返す。 assertion テスターは、入力文字列の現在の位置に対する特殊条件 (クロージャの結合済み引数で特定される) をテストし、条件にマッチすれば true 、マッチしなければ false を返す。
• EscapeValue は、文字または整数である。 EscapeValue を用いて DecimalEscape エスケープシーケンスの解釈をあらわす: 文字 ch は、エスケープシーケンスが文字 ch として解釈されることを意味し、一方整数 n は、エスケープシーケンスが n 番目の捕捉括弧集合の後方参照として解釈されることを意味する。

生成規則 Pattern :: Disjunction は、次のように評価される:

1. Disjunction を評価し、 Matcher m を取得する。
2. 内部クロージャを返す。これは 2 個の引数、文字列 str と整数 index をとり、次を実行する:
   1. Input を与えられた文字列 str とする。この変数は、セクション 15.10.2 内の関数を通して使用される。
   2. InputLength を Input の長さとする。この変数は、セクション 15.10.2 内の関数を通して使用される。
   3. c を、成功の MatchResult として引数 State を常に返す Continuation とする。
   4. cap を、 1 から NCapturingParens までの添え字を持つ NCapturingParens 個の undefined 値 の内部配列とする。
   5. x を State (index, cap) とする。
   6. m(x, c) を呼出し、その結果を返す。

参考情報解説 (Informative comment): Pattern は内部関数値に評価 ("コンパイル") される。 RegExp.prototype.exec がこの関数を適用できるのは、文字列と、文字列内部のオフセットで、それは文字列内部のその厳密なオフセットで開始してパターンがマッチできるかどうかを決定するものである。 そして、マッチするならば、それは捕捉括弧の値となるものである。 セクション 15.10.2 のアルゴリズムは、コンパイルするパターンが例外 SyntaxError を投げてもよいように設計される; 一方、パターンが一旦コンパイルされると、文字列内のマッチを検索する結果の関数の適用は、例外を投げることが出来ない (out-of-memory など、どこでも発生しうる任意のホスト定義の例外を除く)。

生成規則 Disjunction :: Alternative の評価は、 Alternative を評価して取得した Matcher を返す。

生成規則 Disjunction :: Alternative | Disjunction は、次のように評価される:

1. Alternative を評価し Matcher m1 を取得する。
2. Disjunction を評価し Matcher m2 を取得する。
3. 内部 Matcher クロージャを返す。これは 2 個の引数、 State x と Cantinuation x をとり、次を実行する:
   1. m1(x, c) を呼出し、結果を r とする。
   2. r が failure でないならば、 r を返す。
   3. m2(x, c) を呼出し、その結果を返す。

参考情報解説: 正規表現演算子 | は 2 個の代替を区切る。パターンはまず左の Alternative (後に正規表現が続く) のマッチを試行する; 失敗したならば、右の Disjunction (後に正規表現が続く) のマッチを試行する。左の Alternative, 右の Disjunction, 続き全てが選択点を持つならば、続きの全ての選択肢は左の Alternative 内の次の選択肢上への移動前に試行される。左の Alternative 内の選択肢を使い切ったならば、右の Disjunction が左の Alternative の代わりに試行される。 | によりスキップされたパターン成分内部の任意の捕捉括弧は、文字列の代わりに undefined 値を生成する。つまり、例えば

/a|ab/.exec("abc")

は結果 "a" を返し、 "ab" は返さない。もっと言えば

/((a)|(ab))((c)|(bc))/.exec("abc")

は以下の配列

["abc", "a", "a", undefined, "bc", undefined, "bc"]

を返し、

["abc", "ab", undefined, "ab", "c", "c", undefined]

は返さない。

生成規則 Alternative :: [empty] の評価は、Matcher を返す。この Matcher は 2 個の引数 State x と Continuation c をとり、 c(x) の結果を返す。

生成規則 Alternative :: Alternative Term は、次のように評価される:

1. Alternative を評価し、 Matcher m1 を得る。
2. Term を評価し、 Matcher m2 を得る。
3. 内部 Matcher クロージャを返す。このクロージャは 2 個の引数 State x と Continuation c をとり、次のように振舞う:
   1. Continuation d を生成する。これは State 引数に y をとり m2(y, c) の結果を返す
   2. m1(x, d) を呼出し、その結果を返す。

参考情報解説: 連続する Term は、入力文字列の連続する部分の同時マッチを試みる。 左の Alternative, 右の Term, 続きの正規表現の全てが選択ポイントを持つならば、 結果の全選択肢が右の Term の次の選択肢に移動する前に検査され、 右の Term の全ての選択肢が左の Alternative の次の選択肢に移動する前に検査される。

生成規則 Term :: Assertion の評価は 2 個の引数 State x と a Continuation c を取る内部 Matcher クロージャ を返す。このクロージャは次を実行する:

1. Assertion を評価し、 AssertionTester t を取得する。
2. t(x) を呼び出し、結果の boolean 値を r とする。
3. r が false ならば、 failure を返す。
4. c(x) を呼び出し、その結果を返す。

生成規則 Term :: Atom の評価は、 Atom を評価して Matcher を取得し、その Matcher を返す。

生成規則 Term :: Atom Quantifier は、次のように評価される:

1. Atom を評価し、 Matcher m を取得する。
2. Quantifier を評価し、 3 つの結果:整数 min, 整数 (または ∞) max, boolean 値 greedy を取得する。
3. max が有限数で min 未満ならば、例外 SyntaxError を投げる。
4. parenIndex を、正規表現全体でこの生成規則展開の Term の左に発生する左捕捉括弧の数とする。 これは、この生成規則の Term に先行する Atom :: ( Disjunction ) 生成規則の展開総数に、この Term を閉じている Atom :: ( Disjunction ) 生成規則の総数を加えた数である。
5. parenCount を この生成規則の Atom 展開内の左捕捉括弧の数とする。これは、この生成規則の Atom に閉じられる Atom :: ( Disjunction ) 生成規則の総数である。
6. 内部 Matcher クロージャを返す。このクロージャは 2 個の引数 State x と a Continuation c をとり、次のように振舞う:
   1. RepeatMatcher(m, min, max, greedy, x, c, parenIndex, parenCount) を呼び出し、その結果を返す。

内部補助関数 RepeatMatcher は 8 個のパラメタ: Matcher m, 整数 min, 整数 (or ∞) max, boolean 値 greedy, State x, Continuation c, 整数 parenIndex, 整数 parenCount, を取る。そして次のように振舞う:

1. max が zero ならば、 c(x) を呼出しその結果を返す。
2. 内部 Continuation クロージャ d を生成する。このクロージャは 1 個の引数 State y をとり、次のように振舞う:
   • 1. min が zero であり、かつ y の endIndex が x の endIndex と等しいならば、 failure を返す。
   • 2. min が zero ならば、min2 を zero とする; そうでなければ min2 を min-1 とする。
   • 3. max が ∞ ならば、max2 を ∞ とする; そうでなければ max2 を max-1 とする。
   • 4. RepeatMatcher(m, min2, max2, greedy, y, c, parenIndex, parenCount) を呼出し、その結果を返す。
3. cap を x の captures 内部配列の fresh copy とする。
4. parenIndex < k かつ k ≤ parenIndex+parenCount を満たす整数 k のそれぞれについて、 cap[k] を undefined に設定する。
5. e を x の endIndex とする。
6. xr を State (e, cap) とする。
7. min が 0 以外ならば、 m(xr, d) を呼出し、その結果を返す。
8. greedy が true ならば、ステップ 12 へ。
9. c(x) を呼出し、 z をその結果とする。
10. z が failure でないならば、 z を返す。
11. m(xr, d) を呼出し、その結果を返す。
12. m(xr, d) を呼出し、 z をその結果とする。
13. z が failure でないならば、 z を返す。
14. c(x) を呼出し、その結果を返す。

参考情報解説: Quantifier の続く Atom は、 Quantifier で指定された回数だけ繰り返される。量指定子は貪欲でなくすることもできる。その場合、更なる後続のマッチを行ううえで Atom パターンの繰返し回数は可能な限り少ない。また貪欲にすることもできる。その場合、 Atom パターンは後続のマッチに可能な限り多くの回数繰り返される。マッチを行う入力文字列よりもむしろ Atom パターンが繰り返され、したがって Atom の異なる反復は、異なる入力部分文字列とマッチできる。

Atom と続きの正規表現がすべて選択点を持つ場合、 Atom はまず可能な限り多く(最短マッチでは少なく) のマッチを行う。続きの全選択肢は、最後の Atom 反復中での次の選択肢上に移動する前に、試行される。最後 (n 番目) の Atom 反復の全選択肢は、最後から一つ前 (n-1 番目) の Atom 反復中での次の選択肢上に移動する前に、試行される; その時点で、より多くの、またはより少ない Atom の反復が今度は可能であることが判明するかもしれない; (n-1) 番目の Atom の反復の中の次の選択肢上に移動する前に、(可能な限り少なく、または可能な限り多くのいずれかで再開し)、使い尽くされる。

/a[a-z]{2,4}/.exec("abcdefghi")

が "abcde" を返すことに較べて、

/a[a-z]{2,4}?/.exec("abcdefghi")

は "abc" を返す。

また、

/(aa|aabaac|ba|b|c)*/.exec("aabaac")

上の順の選択点による正規表現は

["aaba", "ba"]

という配列を返し、

["aabaac", "aabaac"]
["aabaac", "c"]

とはならない。

上記の選択点の順序は、2 数の最大公約数(単項表記で表す)を算出する正規表現の記述にも使用できる。次の例は、10 と 15 の最大公約数を算出する:

"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/,"$1")

これは単項表記の最大公約数 "aaaaa" を返す。

ステップ 4 の RepeatMatcher は、 Atom が繰り返されるたびに Atom の captures をクリアする。 これは次の正規表現の振る舞いに見ることができる:

/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")

これは次の配列を返し:

["zaacbbbcac", "z", "ac", "a", undefined, "c"]

次のようなものではない。

["zaacbbbcac", "z", "ac", "a", "bbb", "c"]

最も外側の * の各反復が、この場合 2 番目, 3 番目, 4 番目である捕捉文字列を含む、数量化された Atom に含まれていた全ての捕捉された文字列をクリアするためである。

ステップ 1 の RepeatMatcher のクロージャ d は、一旦最小反復数が満たされたらそれ以上空文字列にマッチする Atom の展開を更に反復するために考えないことを宣言する。これは正規表現エンジンがパターンの無限ループに陥ることを防いでおり、次のような正規表現は:

/(a*)*/.exec("b")

また若干複雑には次のようなものは:

/(a*)b\1+/.exec("baaaac")

これらは次の配列を返す:

["b", ""]

生成規則 Assertion :: ^ の評価は、内部 AssertionTester クロージャを返す。これは引数に State x を取り、次を実行する:

1. e を x の endIndex とする。
2. e が 0 ならば、 true を返す。
3. Multiline が false ならば、 false を返す。
4. 文字 Input[e-1] が行終端文字 <LF>, <CR>, <LS>, <PS> のうちの一つならば、 true を返す。
5. false を返す。

生成規則 Assertion :: $ の評価は、内部 AssertionTester クロージャを返す。これは引数に State x を取り、次を実行する:

1. e を x の endIndex とする。
2. e が InputLength と等しいならば、 true を返す。
3. multiline が false ならば、 false を返す。
4. 文字 Input[e] が行終端文字 <LF>, <CR>, <LS>, <PS> のうちの一つならば、 true を返す。
5. false を返す。

生成規則 Assertion :: \ b の評価は、内部 AssertionTester クロージャを返す。これは引数に State x を取り、次を実行する:

1. e を x の endIndex とする。
2. IsWordChar(e-1) を呼び出し、結果の boolean 値を a とする。
3. IsWordChar(e) を呼び出し、結果の boolean 値を b とする。
4. a が true かつ b が false ならば、 true を返す。
5. a が false かつ b が true ならば、 true を返す。
6. false を返す。

生成規則 Assertion :: \ B の評価は、内部 AssertionTester クロージャを返す。これは引数に State x を取り、次を実行する:

1. e を x の endIndex とする。
2. IsWordChar(e-1) を呼び出し、結果の boolean 値を a とする。
3. IsWordChar(e) を呼び出し、結果の boolean 値を b とする。
4. a が true かつ b が false ならば、 false を返す。
5. a が false かつ b が true ならば、 false を返す。
6. true を返す。

内部補助関数 IsWordChar は整数パラメータ e をとり、次を実行する:

1. e == -1 または e == InputLength ならば、 false を返す。
2. c を文字 Input[e] とする。
3. c が下表の 63 文字のうちの一つならば、 true を返す。

   a b c d e f g h i j k l m n o p q r s t u v w x y z
   A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
   0 1 2 3 4 5 6 7 8 9 _

4. false を返す。

生成規則 Quantifier :: QuantifierPrefix は、次のように評価される:

1. QuantifierPrefix を評価し、 2 個の結果: 整数 min と整数 (または ∞) max を取得する。
2. 3 個の結果 min, max, true を返す。

生成規則 Quantifier :: QuantifierPrefix ? は、次のように評価される:

1. QuantifierPrefix を評価し、 2 個の結果: 整数 min と整数 (または ∞) max を取得する。
2. 3 個の結果 min, max, false を返す。

生成規則 QuantifierPrefix :: * の評価は、 2 個の結果 0 と ∞ を返す。

生成規則 QuantifierPrefix :: + の評価は、 2 個の結果 1 と ∞ を返す。

生成規則 QuantifierPrefix :: ? の評価は、 2 個の結果 0 と 1 を返す。

生成規則 QuantifierPrefix :: { DecimalDigits } は、次のように評価される:

1. i を DecimalDigits の数学値とする(セクション 7.8.3 参照)。
2. 2 個の結果 i と i を返す。

生成規則 QuantifierPrefix :: { DecimalDigits , } は、次のように評価される:

1. i を DecimalDigits の数学値とする。
2. 2 個の結果 i と ∞ を返す。

生成規則 QuantifierPrefix :: { DecimalDigits , DecimalDigits } は、次のように評価される:

1. i を 1 個目の DecimalDigits の数学値とする。
2. j を 2 個目の DecimalDigits の数学値とする。
3. 2 個の結果 i と j を返す。

生成規則 Atom :: PatternCharacter は、次のように評価される:

1. ch を PatternCharacter で表される文字とする。
2. A を文字 ch を含む 1 要素 CharSet とする。
3. CharacterSetMatcher(A, false) を呼出し、結果の Matcher を返す。

生成規則 Atom :: . は、次のように評価される:

1. A を 4 個の行終端文字 <LF>, <CR>, <LS>, <PS> を除く全て文字の集合とする。
2. CharacterSetMatcher(A, false) を呼び出し、その結果の Matcher を返す。

生成規則 Atom :: \ AtomEscape の評価は、 AtomEscape を評価して Matcher を取得し、その Matcher を返す。

生成規則 Atom :: CharacterClass は、次のように評価される:

1. CharacterClass を評価し、 CharSet A と boolean 値 invert を取得する。
2. CharacterSetMatcher(A, invert) を呼び出し、その結果の Matcher を返す。

生成規則 Atom :: ( Disjunction ) は、次のように評価される:

1. Disjunction を評価し、 Matcher m を取得する。
2. parenIndex を、正規表現全体において、この生成規則展開の最初の左括弧の左側に発生する左捕捉括弧の数とする。これは、この生成規則の Atom に先行する Atom :: ( Disjunction ) 生成規則の展開総数に、この Atom を閉じている Atom :: ( Disjunction ) 生成規則の総数を加えたものである。
3. 内部 Matcher クロージャを返す。このクロージャは 2 個の引数 State x and a Continuation c をとり、次のように振舞う:
   1. 内部 Continuation クロージャ d を作成する。このクロージャは 1 個の引数 State y をとり、次のように振舞う:
      1. cap を y の captures 内部配列の初期の複製 (fresh copy) とする。
      2. xe を x の endIndex とする。
      3. ye を y の endIndex とする。
      4. s を、 Input の 位置 xe から ye の直前までの文字を持つ fresh string とする。
      5. cap[parenIndex+1] を s に設定する。
      6. z を State (ye, cap) とする。
      7. c(z) を呼出し、その結果を返す。
   2. m(x, d) を呼出し、その結果を返す。

生成規則 Atom :: ( ? : Disjunction ) の評価は、 Disjunction を評価して Matcher を取得し、その Matcher を返す。

生成規則 Atom :: ( ? = Disjunction ) は、次のように評価される:

1. Disjunction を評価して Matcher m を取得する。
2. 内部 Matcher クロージャを返す。そのクロージャは 2 個の引数 State x と Continuation c をとり、次のように振舞う:
   1. d を、成功する MatchResult としてその State 引数を常に返す Continuation とする。
   2. m(x, d) を呼出し、 r をその結果とする。
   3. r が failure ならば、 failure を返す。
   4. y を r の State とする。
   5. cap を y の captures 内部配列とする。
   6. xe を x の endIndex とする。
   7. z を State (xe, cap) とする。
   8. c(z) を呼出し、その結果を返す。

生成規則 Atom :: ( ? ! Disjunction ) は、次のように評価される:

1. Disjunction を評価して Matcher m を取得する。
2. 内部 Matcher クロージャを返す。そのクロージャは 2 個の引数 State x と Continuation c をとり、次のように振舞う:
   1. d を、成功する MatchResult としてその State 引数を常に返す Continuation とする。
   2. m(x, d) を呼出し、 r をその結果とする。
   3. r が failure でないならば、 failure を返す。
   4. c(x) を呼出し、その結果を返す。

内部補助関数 CharacterSetMatcher は 2 個の引数 CharSet A と boolean フラグ invert をとり、次のように振舞う:

1. 内部 Matcher クロージャを返す。そのクロージャは 2 個の引数 State x と Continuation c をとり、次のように振舞う:
   1. e を x の endIndex とする。
   2. e == InputLength ならば、 failure を返す。
   3. c を 文字 Input[e] とする。
   4. cc を Canonicalize(c) の結果とする。
   5. invert が true ならば、 ステップ 8 へ。
   6. 集合 A に、 Canonicalize(a) == cc であるような元が存在しないならば、 failure を返す。
   7. ステップ 9 へ。
   8. 集合 A に、 Canonicalize(a) == cc であるような元が存在するならば、 failure を返す。
   9. cap を x の captures 内部配列とする。
   10. y を State (e+1, cap) とする。
   11. c(y) を呼出し、その結果を返す。

内部補助関数 Canonicalize はパラメタに文字 ch をとり、次のように振舞う:

1. IgnoreCase が false ならば、 ch を返す。
2. u を ch を大文字に変換したものとする。これは文字列 ch に String.prototype.toUpperCase を呼出すのと同様のものである。
3. u が単一の文字により構成されるものでないならば、 ch を返す。
4. cu を u の文字とする。
5. ch のコードポイント値が 10 進数で 128 以上であり、かつ cu のコードポイント値が 10 進数で 128 未満ならば、 ch を返す。
6. cu を返す。

参考情報解説: ( Disjunction ) 形式の括弧は、 Disjunction パターンのグループ成分とともに、マッチ結果の保存を提示する。結果は後方参照 (\ に 0 以外の10進数が続くもの)、置換文字列内での参照に用いられ、また正規表現マッチ関数から配列の一部を返される。括弧の捕捉の振る舞いの抑制には、代わりに (?: Disjunction ) 形式を用いる。

(?= Disjunction ) 形式は、 0 文字幅の肯定の先読みを指定する。成功するためには Disjunction 内部のパターンは現在位置においてマッチしなければならないが、後続のマッチングの前に現在位置は前進しない。 Disjunction が現在位置におけるマッチに何通りかある場合は、最初のものだけが検査される。他の正規表現演算子とは異なり、 (?= 形式内への後方参照は存在しない (この独特の振る舞いは Perl から継承される)。 Disjunction が捕捉括弧とその捕捉への後方参照を含む後続のパターンで構成されるとき、このことが重要になる。

例えば、

/(?=(a+))/.exec("baaabac")

は、 1 個目の b の直後の空文字列にマッチし、それゆえ次の配列を返す:

["", "aaa"]

先読みへ後方参照の不足の例として、次を考えてみる:

/(?=(a+))a*b\1/.exec("baaabac")

この式が返すのは次であり:

["aba", "a"]

次のようにはならない:

["aaaba", "a"]

(?= Disjunction ) 形式は、 0 文字幅の否定の先読みを指定する。成功するためには Disjunction 内部のパターンは現在位置においてマッチに失敗しなければならない。現在位置は後続のマッチングの前に前進しない。 Disjunction には捕捉括弧を含められるが、それらへの後方参照は Disjunction 自身内部からの場合ものみ意味を持つ。パターン内の他の場所からのこれらの捕捉括弧への後方参照は、パターンに否定の先読みが成功してはならないため、常に undefined を返す。例えば:

/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")

は、ある正の数 n 個の a, 1 個の b, 他の n 個の (1 個目の \2 で指定される) a, 1 個の c, が直後に続かないような 1 個の a を検索する。 2 個目の \2 は否定の先読みの外部であり、したがって undefined に対してマッチするので常に成功する。式全体は次の配列を返す:

["baaabaac", "ba", undefined, "abaac"]

文字ケースを区別しないマッチでは、全ての文字は比較の直前に暗黙に大文字に変換される。しかし、大文字への変換が 1 個以上の文字に展開される場合("ß" (\u00DF) から "SS" に変換など)は、代わりに文字はそのまま残される。 ASCII 文字でなくても、大文字への変換がその文字を ASCII 文字にする場合、その文字は残される。これは /[a-z]/i のような ASCII 文字のマッチのみを意図した正規表現のマッチから、\u0131 \u017F のような Unicode 文字を遮る。なお、これらの変換が許可される場合、 /[^\W]/i は a, b, ..., h, にはマッチするが i や s にはマッチしない。

生成規則 AtomEscape :: DecimalEscape は、次のように評価される:

1. DecimalEscape を評価して EscapeValue E を取得する。
2. E が文字でなければ、ステップ 6 へ。
3. ch を E の文字とする。
4. A を文字 ch を含む要素1個の CharSet とする。
5. CharacterSetMatcher(A, false) を呼出し、結果の Matcher を返す。
6. E は整数でなければならない。 n をその整数とする。
7. n=0 または n>NCapturingParens ならば、例外 SyntaxError を投げる。
8. 内部 Matcher クロージャを返す。このクロージャは 2 個の引数、 State x と Continuation c をとり、次のように振舞う:
   1. cap を x の captures の内部配列とする。
   2. s を cap[n] とする。
   3. s が undefined ならば、 c(x) を呼出し、その結果を返す。
   4. e を x の endIndex とする。
   5. len を s の length とする。
   6. f を e+len とする。
   7. f>InputLength ならば、 failure を返す。
   8. Canonicalize(s[i]) が Canonicalize(Input [e+i]) と同じ文字でないような 0 以上 len 未満の整数 i が存在するならば、 failure を返す。
   9. y を State (f, cap) とする。
   10. c(y) を呼出し、その結果を返す。

生成規則 AtomEscape :: CharacterEscape は、次のように評価される:

1. CharacterEscape を評価し、文字 ch を取得する。
2. A を文字 ch を含む要素1個の CharSet とする。
3. CharacterSetMatcher(A, false) を呼出し、結果の Matcher を返す。

生成規則 AtomEscape :: CharacterClassEscape は、次のように評価される:

1. CharacterClassEscape を評価し、 CharSet A を取得する。
2. CharacterSetMatcher(A, false) を呼出し、結果の Matcher を返す。

参考情報解説: \ に 0 以外の10進数 n の続く形式のエスケープシーケンスは、捕捉括弧の n 番目の集合 (セクション 15.10.2.11) の結果にマッチする。正規表現中の捕捉括弧が n 個未満である場合はエラーである。正規表現が n 個以上の捕捉括弧を持つが n 番目が何も捕捉されず undefined である場合、その後方参照は常に成功する。

生成規則 CharacterEscape :: ControlEscape の評価は、下の表に従って文字を返す:

生成規則 CharacterEscape :: c ControlLetter は、次のように評価される:

1. ch を ControlLetter で表される文字とする。
2. i を ch のコードポイント値とする。
3. j を i を 32 で割った余りとする。
4. j を番号とする Unicode 文字を返す。

生成規則 CharacterEscape :: HexEscapeSequence の評価は、 HexEscapeSequence の文字値 (セクション 7.8.4) を評価して、結果の文字を返す。

生成規則 CharacterEscape :: UnicodeEscapeSequence の評価は、 UnicodeEscapeSequence の文字値 (セクション 7.8.4) を評価して、結果の文字を返す。

生成規則 CharacterEscape :: IdentityEscape の評価は、 IdentityEscape で表される文字を返す。

生成規則 DecimalEscape :: DecimalIntegerLiteral [lookahead ∉ DecimalDigit] は、次のように評価される。

1. i を DecimalIntegerLiteral の数学値とする。
2. i が 0 ならば、 <NUL> 文字 (Unicode 値 0000) を構成する EscapeValue を返す。
3. 整数 i で構成する EscapeValue を返す。

"DecimalIntegerLiteral の数学値" の定義はセクション 7.8.3 である。

参考情報解説: 最初の数字が0以外である10進数 n が \ に続く場合、そのエスケープシーケンスは後方参照として考える。正規表現全体の左捕捉括弧の総数よりも n が大きい場合はエラーである。 \0 は NUL 文字を表し、10進数字を後に続けることはできない。

生成規則 CharacterClassEscape :: d の評価は、0 から 9 までを含む文字の 10 個の要素集合を返す。

生成規則 CharacterClassEscape :: D の評価は、 CharacterClassEscape :: d が返す集合を除く全ての文字の集合を返す。

生成規則 CharacterClassEscape :: s の評価は、 WhiteSpace (セクション 7.2) または LineTerminator (セクション 7.3) 生成規則の右辺上の文字を含む文字集合を返す。

生成規則 CharacterClassEscape :: S の評価は、 CharacterClassEscape :: s が返す集合を除く全ての文字集合を返す。

生成規則 CharacterClassEscape :: w の評価は、 63 個の文字を含む文字の集合を返す:

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 _

生成規則 CharacterClassEscape :: W の評価は、 CharacterClassEscape :: w が返す集合を除く全ての文字集合を返す。

生成規則 CharacterClass :: [ [lookahead ∉ {^}] ClassRanges ] の評価は、 ClassRanges を評価して CharSet を取得し、その CharSet とブーリアン値 false を返す。

生成規則 CharacterClass :: [ ^ ClassRanges ] の評価は、 ClassRanges を評価して CharSet を取得し、その CharSet とブーリアン値 true を返す。

生成規則 ClassRanges :: [empty] の評価は、空の CharSet を返す。

生成規則 ClassRanges :: NonemptyClassRanges の評価は、 NonemptyClassRanges を評価して CharSet を取得し、その CharSet を返す。

生成規則 NonemptyClassRanges :: ClassAtom の評価は、 ClassAtom を評価して CharSet を取得し、その CharSet を返す。

生成規則 NonemptyClassRanges :: ClassAtom NonemptyClassRangesNoDash は、次のように評価される:

1. ClassAtom を評価し、 CharSet A を取得する。
2. NonemptyClassRangesNoDash を評価し、 CharSet B を取得する。
3. CharSet A と B の和集合を返す。

生成規則 NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges は、次のように評価される:

1. 1 つ目の ClassAtom を評価し CharSet A を取得する。
2. 2 つ目の ClassAtom を評価し CharSet B を取得する。
3. ClassRanges を評価し CharSet C を取得する。
4. CharacterRange(A, B) を呼出し、D を結果の CharSet とする。
5. CharSet D と C の和集合を返す。

内部補助関数 CharacterRange は、 2 個の CharSet パラメータ A と B をとり、次を実行する:

1. A が厳密な 1 個の文字を含まない、または B が厳密な 1 個の文字を含まないならば、例外 SyntaxError を投げる。
2. a を、 CharSet A 内の 1 個の文字とする。
3. b を、 CharSet B 内の 1 個の文字とする。
4. i を、文字 a のコードポイント値とする。
5. j を、文字 b のコードポイント値とする。
6. i > j ならば、例外 SyntaxError を投げる。
7. i から j までの番号をもつ文字全てを含む集合を返す。

生成規則 NonemptyClassRangesNoDash :: ClassAtom 評価は、 ClassAtom 評価で CharSet を取得し、その CharSet を返す。

生成規則 NonemptyClassRangesNoDash :: ClassAtomNoDash NonemptyClassRangesNoDash は、次のように評価される::

1. ClassAtomNoDash を評価し、 CharSet A を取得する。
2. NonemptyClassRangesNoDash を評価し、 CharSet B を取得する。
3. CharSets A と B の和集合を返す。

生成規則 NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges は、次のように評価される::

1. ClassAtomNoDash を評価し、 CharSet A を取得する。
2. ClassAtom を評価し、 CharSet B を取得する。
3. ClassRanges を評価し、 CharSet C を取得する。
4. CharacterRange(A, B) を呼出し、 D を結果の CharSet とする。
5. CharSet D と C の和集合を返す。

参考情報解説: ClassRanges は、単一の ClassAtom そして/または ダッシュで区切られた 2 個の ClassAtom の範囲に展開してよい。文字ケースについては、 ClassRanges は 1 つ目の ClassAtom と 2 つ目の ClassAtom までの間の全ての文字を含む。 ClassAtom が単一の文字を表さない (例えば、一方が \w) ならば、また 1 つ目の ClassAtom のコードポイント値が 2 つ目の ClassAtom のコードポイント値より大きいならば、エラーが発生する。

パターンが文字ケースを区別しないとしても、範囲の両端の文字ケースは、文字の範囲への所属判定において重要である。たとえば、パターン /[E-F]/i は文字 E, F, e, f にのみマッチするのに対して、パターン /[E-f]/i は大文字小文字含めた ASCII 文字だけでなく記号 [, \, ], ^, _, ` にもマッチする。

文字 - は文字通りに扱われうるか、範囲を示せるかである。 - が文字通りに扱われるのは、それが ClassRanges の最初または最後の文字である場合、範囲指定の先頭または末尾である場合、直後に範囲指定が続く場合である。

生成規則 ClassAtom :: - の評価は、 1 個の文字 - で構成される CharSet を返す。

生成規則 ClassAtom :: ClassAtomNoDash の評価は、 ClassAtomNoDash 評価で CharSet を取得し、その CharSet を返す。

生成規則 ClassAtomNoDash :: SourceCharacter but not one of \ ] - の評価は、 SourceCharacter で表される文字で構成される 1 要素の CharSet を返す。

生成規則 ClassAtomNoDash :: \ ClassEscape の評価は、 ClassEscape 評価で CharSet を取得し、その CharSet を返す。

生成規則 ClassEscape :: DecimalEscape は、次のように評価される:

1. DecimalEscape を評価し、 EscapeValue E を取得する。
2. E が文字でなければ、 例外 SyntaxError を投げる。
3. ch を E の文字とする。
4. 文字 ch で構成される、 1 要素の CharSet を返す。

生成規則 ClassEscape :: b は、 1 個の文字 <BS> (Unicode 値 0008) で構成される CharSetを返して評価される。

生成規則 ClassEscape :: CharacterEscape の評価は、 CharacterEscape 評価で文字を取得し、その文字で構成される 1 要素の CharSet を返す。

生成規則 ClassEscape :: CharacterClassEscape の評価は、 CharacterClassEscape 評価で CharSet を取得し、その CharSet を返す。

参考情報解説: ClassAtom は、 \b, \B, 後方参照を除く残りの正規表現で許される任意のエスケープシーケンスを使用できる。 CharacterClass 内部において、 \b は後退文字 (backspace character) を意味し、一方 \B と後方参照はエラーを発生させる。 ClassAtom 内部での後方参照の使用はエラーを引き起こす。

pattern が [[Class]] プロパティが "RegExp" であるオブジェクト R で、かつ flags が undefined ならば、 R をそのまま返す。そうでなければ RegExp コンストラクタ (セクション 15.10.4.1) を呼出し、それに引数 pattern と flags を渡し、そのコンストラクタに構築されるオブジェクトを返す。

pattern が [[Class]] プロパティが "RegExp" である オブジェクト R で、かつ flags が undefined ならば、 P を R の構築に用いる pattern とし、 F を R の構築に用いる flags とする。 pattern が [[Class]] プロパティが "RegExp" である オブジェクト R で、かつ flags が undefined でないならば、 例外 TypeError を投げる。 そうでなければ、 P を pattern が undefined ならば空文字列、そうでなければ ToString(pattern) とし、 F を flags が undefined ならば空文字列、そうでなければ ToString(flags) とする。

新規に構築されたオブジェクトの global プロパティは、 F が文字 "g" を含めば true, そうでなければ false である Boolean 値に設定される。

新規に構築されたオブジェクトの ignoreCase プロパティは、 F が文字 "i" を含めば true, そうでなければ false である Boolean 値に設定される。

新規に構築されたオブジェクトの multiline プロパティは、 F が文字 "m" を含めば true, そうでなければ false である Boolean 値に設定される。

F が "g", "i", "m" 以外の文字を含むならば、また一旦出現したものと同じものを含むならば、例外 SyntaxError を投げる。

P の文字が書式 Pattern を持たないならば、例外 SyntaxError を投げる。そうでなければ、新規に構築されたオブジェクトに Pattern の評価 ("compiling") により得られる [[Match]] プロパティを持たせる。 Pattern の評価が例外 SyntaxError を投げてもよいことに注意。 (Note: pattern が StringLiteral ならば、 文字列が RegExp によって処理される前に、通常のエスケープシーケンスの変換が実行される。 RegExp によって認識されるエスケープシーケンスを pattern に含めなければならないならば、 StringLiteral の内容の形成時に削除されることを防ぐために、 StringLiteral 内の文字 "\" はエスケープされなければならない。)

新規に構築されたオブジェクトの source プロパティは、 P に基づくPattern の書式の実装依存の文字列値に設定される。

新規に構築されたオブジェクトの lastIndex プロパティは、 0 に設定される。

新規に構築されたオブジェクトの [[Prototype]] プロパティは、 RegExp.prototype の初期値であるオリジナルの RegExp プロトタイプオブジェクトに設定される。

新規に構築されたオブジェクトの [[Class]] プロパティは、 "RegExp" に設定される

RegExp.prototype の初期値は RegExp プロトタイプオブジェクト (セクション 15.10.6) である。

このプロパティは属性 { DontEnum, DontDelete, ReadOnly } を持つべきである。

RegExp.prototype.constructor の初期値は、組込み RegExp コンストラクタである。

正規表現に対して string の正規表現マッチを行い、マッチの結果を含む Array オブジェクト、また文字列にマッチしなかった場合は null を返す。

文字列 ToString(string) は、次のように正規表現パターンの発生を検索される:

1. S を ToString(string) の値とする。
2. length を S の長さとする。
3. lastIndex を lastIndex プロパティの値とする。
4. i を ToInteger(lastIndex) の値とする。
5. global プロパティが false ならば、 i = 0 とする。
6. I < 0 または I > length ならば、 lastIndex を 0 に設定し、 null を返す。
7. [[Match]] と呼出し、引数に S と i を与える。 [[Match]] が failure を返したならば、 ステップ 8 へ; そうでなければ、 r をその State 結果とし、 ステップ 10 へ。
8. i = i+1 とする。
9. ステップ 6 へ。
10. e を r の endIndex 値とする。
11. global プロパティが true ならば、 lastIndex を e に設定する。
12. n を r の captures 配列の長さとする。 (これは、セクション 15.10.2.1 の NCapturingParens と同じ値である。)
13. 次のプロパティを持つ新しい配列を返す:
    • * index プロパティは、完全な文字列 S 内でマッチした部分文字列の位置に設定される。
    • * input プロパティは、 S に設定される。
    • * length プロパティは、 n + 1 に設定される。
    • * 0 プロパティは、マッチした部分文字列 (すなわち オフセット i からオフセット e の前までの間のS の成分) に設定される。
    • * I > 0 かつ I ≤ n であるような整数 i のそれぞれについて、 ToString(i) を名前とするプロパティに r の captures 配列の i 番目の要素を設定する。

式 RegExp.prototype.exec(string) != null と同様である。

src を現在の正規表現を表す Pattern の書式の文字列とする。 src は、 source プロパティまた RegExp コンストラクタに供給されるソースコードと同一であってもなくてもよい; ただ、 src が現在の正規表現の flags を伴って RegExp コンストラクタに供給されたならば、結果の正規表現は、現在の正規表現と同様に振るまわなければならない。

toString は、文字列 "/", src, "/" の連結で形成される文字列を返す; global プロパティが true ならば "g"、 ignoreCase プロパティが true ならば "i"、 multiline プロパティが true ならば "m" を、連結する文字列に追加する。

source プロパティの値は、 現在の正規表現をあらわす Pattern の書式の文字列値である。このプロパティは、属性 { DontDelete, ReadOnly, DontEnum } を持つべきである。

global プロパティの値は、 flags が文字 "g" を含むかどうかを示す Boolean 値である。このプロパティは、属性 { DontDelete, ReadOnly, DontEnum } を持つべきである。

ignoreCase プロパティの値は、 flags が文字 "i" を含むかどうかを示す Boolean 値である。このプロパティは、属性 { DontDelete, ReadOnly, DontEnum } を持つべきである。

multiline プロパティの値は、 flags が文字 "m" を含むかどうかを示す Boolean 値である。このプロパティは、属性 { DontDelete, ReadOnly, DontEnum } を持つべきである。

lastIndex プロパティの値は、文字列の次のマッチを開始する位置を特定する整数である。このプロパティは、属性 { DontDelete, DontEnum } を持つべきである。