js_object-RegExp_ - 0x0b

Syntax

Pattern ::
Disjunction
Disjunction ::
Alternative
Alternative | Disjunction
Alternative ::
[empty]
Alternative Term
Term ::
Assertion
Atom
Atom Quantifier
Assertion ::
^
$
\ b
\ B
Quantifier ::
QuantifierPrefix
QuantifierPrefix ?
QuantifierPrefix ::
*

?
{ DecimalDigits }
{ DecimalDigits , }
{ DecimalDigits , DecimalDigits }
Atom ::
PatternCharacter
.
\ AtomEscape
CharacterClass
( Disjunction )
( ? : Disjunction )
( ? = Disjunction )
( ? ! Disjunction )
PatternCharacter :: SourceCharacter but not any of:
^ $ \ . * + ? ( ) [ ] { } |
AtomEscape ::
DecimalEscape
CharacterEscape
CharacterClassEscape
CharacterEscape ::
ControlEscape
c ControlLetter
HexEscapeSequence
UnicodeEscapeSequence
IdentityEscape
ControlEscape :: one of
f n r t v
ControlLetter :: one of
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
IdentityEscape ::
SourceCharacter but not IdentifierPart
DecimalEscape ::
DecimalIntegerLiteral [lookahead ( DecimalDigit]
CharacterClassEscape :: one of
d D s S w W
CharacterClass ::
[ [lookahead ∉ {^} ] ClassRanges ]
[ ^ ClassRanges ]
ClassRanges ::
[empty]
NonemptyClassRanges
NonemptyClassRanges ::
ClassAtom
ClassAtom NonemptyClassRangesNoDash
ClassAtom - ClassAtom ClassRanges
NonemptyClassRangesNoDash ::
ClassAtom
ClassAtomNoDash NonemptyClassRangesNoDash
ClassAtomNoDash - ClassAtom ClassRanges
ClassAtom ::

ClassAtomNoDash
ClassAtomNoDash ::
SourceCharacter but not one of \ ] -
\ ClassEscape
ClassEscape ::
DecimalEscape
b
CharacterEscape
CharacterClassEscape

表記法(Notation)

**変数$

Input[n]
InputLength
NCaputuringParens
IgnoreCase
Multiline

内部データ構造

Charset
State (endIndex, captures) @(Int, NCaputuringParens) Index+1 undefined
MatchResult state/特殊トークン failure
Continuation関数 内部クロージャ (すなわち、引数が既に値に結合されている内部関数) 1state MatchResult
Matcher関数 state continuation MatchResult
AssersionTester関数 state true/false
EscapeValue エスケープシーケンス(シークエンス) 文字ch 捉括弧集合の後方参照

Pattern

Disjunction

正規表現演算子 | は 2 個の代替を区切る

/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

Term

/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", ""]

Asertion

^
$
\b
\B
内部補助関数 IsWordChar 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 _

Quantifier

QuantifierPrefix?
min, max, true

0, infinite

1. 1, infinite

? 0, 1
{ DecimalDigits } i, i
{ DecimalDigits, } i< infinite
{ DecimalDigits, DecimalDigits } i, j

Atom

行終端文字 <LF>, <CR>, <LS>, <PS> 以外の文字集合
\ AtomEscape
CharacterClass
( Disjunction )
( ? : Disjunction )
( ? ! Disjunction )
内部補助関数 CharacterSetMatcher
内部補助関数 Canonicalize
参考情報解説: ( 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

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

CharacterEscape

ControlEscape

ControlEscape	Unicode Value	Name	Symbol
t	\u0009	horizontal tab	<HT>
n	\u000A	line feed (new line)	<LF>
v	\u000B	vertical tab	<VT>
f	\u000C	form feed	<FF>
r	\u000D	carriage return	<CR>

c ControlLetter
HexEscapeSequence
UnicodeEscapeSequence
IdentityEscape

DecimalEscape

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

CharacterClassEscape

d 0-9
D 0-9以外
s WhiteSpace, LineTerminatorを含む文字集合
S s以外
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 _

CharacterClass

[ [lookahead ∉ {^}] ClassRanges ] charset, boolean(false)
[ ^ ClassRanges ] charset, boolean(true)

ClassRanges

[empty] 空のCharset
NonemptyClassRanges charset

NonemptyClassRanges

ClassAtom charset
ClassAtom NonemptyClassRangesNoDash
ClassAtom - ClassAtom ClassRanges

NoemptyClassRangesNoDash

ClassAtom charset
ClassAtomNoDash NonemptyClassRangesNoDash
ClassAtomNoDash - ClassAtom ClassRanges
参考情報解説: 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

ClassAtomNoDash

ClassEscape

関数として呼出される RegExp コンストラクタ

patternClass プロパティが "RegExp" であるオブジェクト R で、かつ flags が undefined ならば、 R を返す
それ以外はRegExp コンストラクタ呼出、引数 pattern と flags を渡しコンストラクタに構築されたオブジェクトを返す

RegExp コンストラクタ

new式の一部で呼出されたらコンストラクタ
生成されるオブジェクトを初期化

new RegExp(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 コンストラクタのプロパティ

RegExp コンストラクタのの内部 Prototype プロパティの値は、 Function プロトタイプオブジェクト
内部プロパティと length プロパティ (値は 2) の他に、 RegExp コンストラクタは次のプロパティを持つ:

RegExp.prototype

RegExp.prototype の初期値は RegExp プロトタイプオブジェクト

RegExp プロトタイプオブジェクトのプロパティ

RegExp プロトタイプオブジェクトの内部 Prototype プロパティの値は、 Object プロトタイプである。 RegExp プロトタイプオブジェクトの内部 Class プロパティの値は、 "Object" である。
RegExp プロトタイプオブジェクトは、独自の valueOf プロパティを持たない; しかしながら、 valueOf プロパティを Object プロトタイプオブジェクトから継承する。
RegExp プロトタイプオブジェクトのプロパティである関数の以下の説明において、フレーズ "この RegExp オブジェクト" は、関数呼出しの this 値であるオブジェクトを参照する; this 値 が内部 Class プロパティが "RegExp" のオブジェクトでない場合は、例外 TypeError が投げられる。

RegExp.prototype.constructor

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

RegExp.prototype.exec(string)

正規表現に対して string の正規表現マッチを行い、マッチの結果を含む Array オブジェクト、また文字列にマッチしなかった場合は null を返す。
文字列 ToString(string) は、次のように正規表現パターンの発生を検索される:

RegExp.prototype.test(string)

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

RegExp.prototype.toString()

src を現在の正規表現を表す Pattern の書式の文字列とする。 src は、 source プロパティまた RegExp コンストラクタに供給されるソースコードと同一であってもなくてもよい; ただ、 src が現在の正規表現の flags を伴って RegExp コンストラクタに供給されたならば、結果の正規表現は、現在の正規表現と同様に振るまわなければならない。
toString は、文字列 "/", src, "/" の連結で形成される文字列を返す; global プロパティが true ならば "g"、 ignoreCase プロパティが true ならば "i"、 multiline プロパティが true ならば "m" を、連結する文字列に追加する。
NOTE 実装は、 src 内の特殊文字をエスケープするために、 RegExp コンストラクタへ渡されるソースと異なることを許可されている src の利用を選択してよい。例えば、 new RegExp("/") から得られる正規表現において、 src は、数ある可能性の中から、 "/" または "\/" でありえる。後者は、書式 RegularExpressionLiteral を持つ toString 呼出しの完全な結果 ("/\//") を許可する。

RegExp インスタンスのプロパティ

RegExp インスタンスは、上記に指定されるその Prototype オブジェクトからプロパティを継承し、また次のプロパティを持つ。

source

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

global

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

ignoreCase

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

multiline

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

lastIndex

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