一般的なアトムの構文は次のとおりです。

文字クラスの構文は次のとおりです。

次の構成はすべて文字仕様です。

文字クラスの使用を説明するために、この例ではISO 8601標準でフォーマットされた日付を解析します。

function parseIsoDate(str) {
    var match = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(str);

    // Other ways of writing the regular expression:
    // /^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$/
    // /^(\d\d\d\d)-(\d\d)-(\d\d)$/

    if (!match) {
        throw new Error('Not an ISO date: '+str);
    }
    console.log('Year: '  + match[1]);
    console.log('Month: ' + match[2]);
    console.log('Day: '   + match[3]);
}

そして、これは相互作用です。

> parseIsoDate('2001-12-24')
Year: 2001
Month: 12
Day: 24

グループの構文は次のとおりです。

\1、\2 などは、後方参照として知られています。これらは、以前に一致したグループを参照します。バックスラッシュの後の数字は1以上の任意の整数にすることができますが、最初の数字は0であってはなりません。

この例では、後方参照はダッシュの前後のaの量が同じであることを保証します。

> /^(a+)-\1$/.test('a-a')
true
> /^(a+)-\1$/.test('aaa-aaa')
true
> /^(a+)-\1$/.test('aa-a')
false

この例では、後方参照を使用してHTMLタグに一致させます（明らかに、HTMLを処理するには通常、適切なパーサーを使用する必要があります）。

> var tagName = /<([^>]+)>[^<]*<\/\1>/;
> tagName.exec('<b>bold</b>')[1]
'b'
> tagName.exec('<strong>text</strong>')[1]
'strong'
> tagName.exec('<strong>text</stron>')
null

任意のアトム（文字クラスやグループを含む）に、量指定子を続けることができます。

デフォルトでは、量指定子は貪欲です。つまり、可能な限り多くの一致を探します。先行する量指定子（中括弧内の範囲を含む）のいずれかに疑問符（?）を付けることで、非貪欲な一致（可能な限り少なく）にできます。例えば：

> '<a> <strong>'.match(/^<(.*)>/)[1]  // greedy
'a> <strong'
> '<a> <strong>'.match(/^<(.*?)>/)[1]  // reluctant
'a'

したがって、.*? は、次のアトムが次に現れるまですべてに一致するのに便利なパターンです。例えば、次に示すのは、先ほど示したHTMLタグの正規表現（.*?の代わりに[^<]*を使用）のより簡潔なバージョンです。

/<(.+?)>.*?<\/\1>/

次のリストに示すアサーションは、入力内の現在の位置に関するチェックです。

(?!«pattern»)

> /\bell\b/.test('hello')
false
> /\bell\b/.test('ello')
false
> /\bell\b/.test('ell')
true

否定先読み：pattern が次に続くものと一致しない場合のみ一致します。pattern は先読みするためだけに使用されますが、それ以外は無視されます。

> /\Bell\B/.test('ell')
false
> /\Bell\B/.test('hell')
false
> /\Bell\B/.test('hello')
true

後読みはサポートされていません。後読みの手動実装では、手動で実装する方法を説明します。

論理和

> /^aa|bb$/.test('aaxx')
true
> /^aa|bb$/.test('xxbb')
true

論理和演算子（|）は、2つの選択肢を区切ります。論理和が一致するには、どちらかの選択肢が一致する必要があります。選択肢はアトムです（オプションで量指定子を含みます）。

/^(aa|bb)$/

演算子は非常に緩やかにバインドするため、選択肢が広がりすぎないように注意する必要があります。例えば、次の正規表現は、aaで始まるか、bbで終わるすべての文字列に一致します。

/^a(a|b)b$/

リテラルまたはコンストラクターのいずれかで正規表現を作成し、フラグを使用してその動作を構成できます。

new RegExp('xyz', 'i')

リテラルはロード時にコンパイルされます。次のコードは、評価されるときに例外を引き起こします。

したがって、通常はリテラルを使用する必要がありますが、正規表現を動的に組み立てたい場合は、コンストラクターが必要です。

multiline

正規表現には、以下のインスタンスプロパティがあります。

以下は、フラグのインスタンスプロパティにアクセスする例です。

> var regex = /abc/i;
> regex.ignoreCase
true
> regex.multiline
false

この例では、まずリテラルで、次にコンストラクターで同じ正規表現を作成し、test() メソッドを使用して文字列と一致するかどうかを判断します。

> /abc/.test('ABC')
false
> new RegExp('abc').test('ABC')
false

この例では、大文字と小文字を区別しない正規表現を作成します (フラグ /i)

> /abc/i.test('ABC')
true
> new RegExp('abc', 'i').test('ABC')
true

フラグ /g が設定されていない場合、最初の一致のみが返されます。

> var regex = /a(b+)/;
> regex.exec('_abbb_ab_')
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
0

フラグ /g が設定されている場合、exec() を繰り返し呼び出すと、すべての一致が返されます。戻り値 null は、一致がなくなったことを示します。プロパティ lastIndex は、次回の一致が継続される場所を示します。

> var regex = /a(b+)/g;
> var str = '_abbb_ab_';

> regex.exec(str)
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
6

> regex.exec(str)
[ 'ab',
  'b',
  index: 7,
  input: '_abbb_ab_' ]
> regex.lastIndex
10

> regex.exec(str)
null

ここでは、一致をループ処理します。

var regex = /a(b+)/g;
var str = '_abbb_ab_';
var match;
while (match = regex.exec(str)) {
    console.log(match[1]);
}

次の出力が得られます。

bbb
b

replacement が文字列の場合、その内容は一致箇所を置換するためにそのまま使用されます。唯一の例外は、ドル記号 ($) という特殊文字で、いわゆる置換ディレクティブを開始します:

この例では、一致する部分文字列とその接頭辞および接尾辞を参照します。

> 'axb cxd'.replace(/x/g, "[$`,$&,$']")
'a[a,x,b cxd]b c[axb c,x,d]d'

この例では、グループを参照します。

> '"foo" and "bar"'.replace(/"(.*?)"/g, '#$1#')
'#foo# and #bar#'

replacement が関数の場合、一致箇所を置換する文字列を計算します。この関数には、次のシグネチャがあります。

function (completeMatch, group_1, ..., group_n, offset, inputStr)

completeMatch は前述の $& と同じであり、offset は一致箇所が見つかった場所を示し、inputStr は照合対象です。したがって、特別な変数 arguments を使用してグループにアクセスできます (グループ 1 は arguments[1] など)。例:

> function replaceFunc(match) { return 2 * match }
> '3 apples and 5 oranges'.replace(/[0-9]+/g, replaceFunc)
'6 apples and 10 oranges'

時々、正規表現を手動で組み立てる際、与えられた文字列をそのまま使用したい場合があります。つまり、特殊文字（例えば、*、[）は特殊文字として解釈されるべきではなく、すべてエスケープされる必要があるということです。JavaScriptには、このようなクォーティングを行うための組み込み機能はありませんが、次のような動作をする独自の関数quoteTextをプログラムすることができます。

> console.log(quoteText('*All* (most?) aspects.'))
\*All\* \(most\?\) aspects\.

このような関数は、複数の出現箇所で検索と置換を行う必要がある場合に特に便利です。この場合、検索対象の値は、globalフラグが設定された正規表現である必要があります。quoteText()を使用すると、任意の文字列を使用できます。この関数は次のようになります。

function quoteText(text) {
    return text.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
}

すべての特殊文字はエスケープされます。これは、括弧や角括弧内にある複数の文字をクォートしたい可能性があるためです。

^や$のようなアサーションを使用しない場合、ほとんどの正規表現メソッドはどこにでもパターンを見つけます。例えば：

> /aa/.test('xaay')
true
> /^aa$/.test('xaay')
false

まれなケースですが、すべてにマッチングする、または何にもマッチングしない正規表現が必要になることがあります。例えば、関数がフィルタリングに使用される正規表現をパラメータとして持つ場合があります。そのパラメータが欠落している場合、デフォルト値として、すべてにマッチングする正規表現を与えます。

> new RegExp('').test('dfadsfdsa')
true
> new RegExp('').test('')
true

> new RegExp('')
/(?:)/

> var never = /.^/;
> never.test('abc')
false
> never.test('')
false

先読みはアサーションです。先読みと同様に、パターンを使用して入力内の現在の位置について何かを確認しますが、それ以外は無視されます。先読みとは対照的に、パターンのマッチは、現在の位置で終了する必要があります（そこから開始するのではなく）。

次の関数は、文字列'NAME'の各出現箇所をパラメータnameの値に置き換えますが、その出現箇所の前に引用符がない場合に限ります。引用符は、現在のマッチの前の文字を「手動で」確認することで処理します。

function insertName(str, name) {
    return str.replace(
        /NAME/g,
        function (completeMatch, offset) {
            if (offset === 0 ||
                (offset > 0 && str[offset-1] !== '"')) {
                return name;
            } else {
                return completeMatch;
            }
        }
    );
}

> insertName('NAME "NAME"', 'Jane')
'Jane "NAME"'
> insertName('"NAME" NAME', 'Jane')
'"NAME" Jane'

もう1つの方法は、正規表現でエスケープする可能性のある文字を含めることです。次に、検索対象の文字列に一時的にプレフィックスを追加する必要があります。そうしないと、その文字列の先頭にあるマッチを見逃す可能性があります。

function insertName(str, name) {
    var tmpPrefix = ' ';
    str = tmpPrefix + str;
    str = str.replace(
        /([^"])NAME/g,
        function (completeMatch, prefix) {
            return prefix + name;
        }
    );
    return str.slice(tmpPrefix.length); // remove tmpPrefix
}