path: root/files/ja/web/javascript/guide/regular_expressions/index.html

---
title: 正規表現
slug: Web/JavaScript/Guide/Regular_Expressions
tags:
  - Guide
  - Intermediate
  - JavaScript
  - Reference
  - RegExp
  - Regular Expressions
  - regex
translation_of: Web/JavaScript/Guide/Regular_Expressions
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}</div>

<p class="summary">正規表現とは、文字列内で文字の組み合わせを照合するために用いられるパターンです。JavaScript では、正規表現はオブジェクトでもあります。これらのパターンは {{jsxref("RegExp")}} の {{jsxref("RegExp.exec", "exec")}} および {{jsxref("RegExp.test", "test")}} メソッドや、{{jsxref("String")}} の {{jsxref("String.match", "match")}}、 {{jsxref("String.matchAll", "matchAll")}}、{{jsxref("String.replace", "replace")}}、{{jsxref("String.search", "search")}}、および {{jsxref("String.split", "split")}} メソッドで使用できます。本章では、JavaScript の正規表現について説明します。</p>

<h2 id="Creating_a_Regular_Expression" name="Creating_a_Regular_Expression">正規表現の作成</h2>

<p>正規表現は 2 種類の方法で作成できます :</p>

<p>次のように、スラッシュによって囲まれたパターンからなる正規表現リテラルを使用します :</p>

<pre class="brush: js notranslate">var re = /ab+c/;
</pre>

<p>正規表現リテラルはスクリプトのロード時にその正規表現をコンパイルします。正規表現が一定のままの場合、この方法を使うとよいパフォーマンスが得られます。</p>

<p>また、次のように {{jsxref("RegExp")}} オブジェクトのコンストラクタ関数を呼び出す方法があります :</p>

<pre class="brush: js notranslate">var re = new RegExp('ab+c');
</pre>

<p>コンストラクタ関数を使用すると、実行時にその正規表現をコンパイルします。正規表現パターンが変わることがわかっている場合や、パターンがわからない場合、ユーザーが入力するなど別のソースからパターンを取得する場合は、コンストラクタ関数を使用してください。</p>

<h2 id="Writing_a_Regular_Expression_Pattern" name="Writing_a_Regular_Expression_Pattern">正規表現パターンの記述</h2>

<p>正規表現パターンは、<code>/abc/</code> のような単純な文字、または <code>/ab*c/</code> や <code>/Chapter (\d+)\.\d*/</code> のような単純な文字と特殊文字との組み合わせからなります。最後の例には記憶装置として用いられる丸括弧があります。パターンのこの丸括弧で囲まれた部分でマッチした箇所は、後で使用できるように記憶されます。詳しくは{{anch("Using_Parenthesized_Substring_Matches", "括弧で囲まれた部分文字列のマッチの使用")}}を参照してください。</p>

<h3 id="Using_Simple_Patterns" name="Using_Simple_Patterns">単純なパターンの使い方</h3>

<p>単純なパターンとは、直接マッチしている部分を見つけたい文字から構成されたものです。例えば <code>/abc/</code> というパターンは、実際に 'abc' という文字が一緒にその順で存在しているときだけ、文字列中の文字の組み合わせにマッチします。"Hi, do you know your abc's?" や "The latest airplane designs evolved from slabcraft." といった文字列でのマッチは成功します。どちらの場合でも 'abc' という部分文字列にマッチします。"Grab crab" という文字列では、'abc' という部分文字列が含まれていないためマッチしません。</p>

<h3 id="Using_Special_Characters" name="Using_Special_Characters">特殊文字の使い方</h3>

<p>1 個以上の b を見つけたり、ホワイトスペースを見つけたりといった直接マッチより高度なマッチの検索では、パターンに特殊文字を使用します。例えば <code>/ab*c/</code> というパターンでは、1 個の 'a' とその後ろに続く 0 個以上の 'b' (<code>*</code> は直前のアイテムの 0 回以上の出現を意味します)、そしてそのすぐ後ろに続く 'c' で構成される文字の組み合わせにマッチします。"cbbabbbbcdebc," という文字列では、このパターンは 'abbbbc' という部分文字列にマッチします。</p>

<p>以下のページで、正規表現で使用できる特殊文字の完全なリストとその意味を詳しく説明します。</p>

<dl>
 <dt><a href="/ja/docs/Web/JavaScript/Guide/Regular_Expressions/Assertions">言明</a></dt>
 <dd>言明には、 行や単語の始まり・終わりを示す、境界や、（先読み、後読み、条件式を含む）何らかの方法でマッチが可能なことを示す、その他のパターンが含まれます。</dd>
 <dt><a href="/ja/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes">文字クラス</a></dt>
 <dd>文字や数字の区別など、文字の種類を区別します。</dd>
 <dt><a href="/ja/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">グループと範囲</a></dt>
 <dd>式にある文字のグループと範囲を示します。</dd>
 <dt><a href="/ja/docs/Web/JavaScript/Guide/Regular_Expressions/Quantifiers">数量詞</a></dt>
 <dd>マッチする文字や式の数を示します。</dd>
 <dt><a href="/ja/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes">Unicode プロパティエスケープ</a></dt>
 <dd>大文字と小文字、数学記号、句読点など、Unicode文字のプロパティに基づき区別します。</dd>
</dl>

<p>正規表現で利用可能なすべての特殊文字を単一の表で見たい場合は、以下を参照してください。</p>

<dl>
 <dd>
 <table class="standard-table">
  <caption>正規表現における特殊文字</caption>
  <thead>
   <tr>
    <th scope="col">文字</th>
    <th scope="col">意味</th>
   </tr>
  </thead>
  <tbody>
   <tr>
    <td><a href="#special-backslash" id="special-backslash" name="special-backslash"><code>\</code></a></td>
    <td>
     <p>以下のルールに基づいてマッチします :</p>

     <p>特別な意味を持たない文字の前に付けられたバックスラッシュ文字は、次の文字が特別なもので、文字通りには評価されないことを表します。例えば、前に '\' がない '<code>b</code>' は文字列中のあらゆる箇所の小文字の 'b' にマッチします。つまり、その文字は文字通り評価されます。しかし '<code>\b</code>' という表現はどんな文字にもマッチしません。これは<a href="#special-word-boundary" title="#special-word-boundary">単語区切り</a>を意味します。<br>
      <br>
      特別な意味を持つ文字の前に付けられたバックスラッシュ文字は、次の文字が特別なものでなく、文字通りに評価されることを表します。詳しくは "Escaping" の章を見てください。</p>

     <p>RegExp コンストラクタの引数に文字列を指定して使う場合、文字列リテラル内でのバックスラッシュはエスケープ文字であることを忘れないでください。つまり、パターン内でバックスラッシュを使うためには、文字列リテラル内でそれをエスケープする必要があるのです。 <code>/[a-z]\s/i</code> と <code>new RegExp("[a-z]\\s", "i")</code> は同じ正規表現を作成します。この表現は、A から Z までの範囲の任意の文字とそれに続く 1 つの空白を探します（<code>\s</code> は次以降を見てください）。文字列を引数として指定した新しい RegExp インスタンスで<em>リテラルとしての</em> バックスラッシュを表現するには、文字列レベルと正規表現レベルの両方でバックスラッシュをエスケープする必要があります。つまり、 <code>/[a-z]:\\/i</code> と <code>new RegExp("[a-z]:\\\\","i")</code> は "C:\" にマッチする同じ表現を作成します。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-caret" id="special-caret" name="special-caret"><code>^</code></a></td>
    <td>
     <p>入力の先頭にマッチします。複数行フラグが true にセットされている場合は、改行文字の直後にもマッチします。<br>
      <br>
      例えば、<code>/^A/</code> は "an A" の 'A' にはマッチしませんが、"An E" の 'A' にはマッチします。</p>

     <p>この文字は、文字集合パターンの先頭にある場合は異なる意味を持ちます。例と詳細については<a href="#special-negated-character-set">相補文字集合</a>をご覧ください。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-dollar" id="special-dollar" name="special-dollar"><code>$</code></a></td>
    <td>
     <p>入力の末尾にマッチします。複数行フラグが true にセットされている場合は、改行文字の直前にもマッチします。</p>

     <p>例えば、<code>/t$/</code> は "eater" の 't' にはマッチしませんが、"eat" の 't' にはマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-asterisk" id="special-asterisk" name="special-asterisk"><code>*</code></a></td>
    <td>
     <p>直前の文字の 0 回以上の繰り返しにマッチします。<code>{0,}</code>に相当します。</p>

     <p>例えば、 <code>/bo*/</code> は "A ghost booooed" の 'boooo' や "A bird warbled" の 'b' にマッチしますが、"A goat grunted" ではマッチしません。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-plus" id="special-plus" name="special-plus"><code>+</code></a></td>
    <td>
     <p>直前の文字の 1 回以上の繰り返しにマッチします。<code>{1,}</code>に相当します。</p>

     <p>例えば、<code>/a+/</code>  は "candy" の 'a' や "caaaaaaandy" のすべての a にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-questionmark" id="special-questionmark" name="special-questionmark"><code>?</code></a></td>
    <td>直前の文字の 0 回か 1 回の出現にマッチします。<code>{0,1}</code>に相当します。<br>
     <br>
     例えば、 <code>/e?le?/</code>
     <p>は "angel" の 'el' や "angle" の 'le'、あるいは "oslo" の 'l' にマッチします。</p>
     *、+、?、{} といった量指定子の直後に使用した場合、その量指定子をデフォルトとは逆の{{原語併記("非貪欲","non-greedy")}} （最短）マッチにします。デフォルトは{{原語併記("欲張り","greedy")}}（最長）マッチです。例えば、<code>/\d+/</code> は "123abc" の "123" にマッチしますが、<code>/\d+?/</code> の場合は "1" にだけマッチします。<br>
     <br>
     この特殊文字は、この表の <code>x(?=y)</code> および <code>x(?!y)</code>

     <p>の項目で説明する先読みアサーションでも使用できます。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-dot" id="special-dot" name="special-dot"><code>.</code></a></td>
    <td>
     <p>(小数点) はデフォルトでは改行文字以外のどの 1 文字にもマッチします。</p>

     <p>例えば、 <code>/.n/</code> は "nay, an apple is on the tree" の 'an' や 'on' にはマッチしますが、'nay' にはマッチしません。</p>

     <p><code>s</code> ("dotAll") フラグが true にセットされている場合は、改行文字にもマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-capturing-parentheses" id="special-capturing-parentheses" name="special-capturing-parentheses"><code>(x)</code></a></td>
    <td>
     <p>'x' にマッチし、マッチした内容を記憶します。この括弧は<em>キャプチャリング（格納）括弧</em>と呼ばれます。<br>
      <br>
      例えば、パターン<code>/(foo) (bar)\1 \2/</code>内の '<code>(foo)</code>' と '<code>(bar)</code>' は、文字列 "foo bar foo bar" の最初の 2 個の単語にマッチし、それを記憶します。パターン内の <code>\1</code> と<code>\2</code> の 1 個目と 2 個目の括弧内の文字、すなわち <code>foo</code> と <code>bar</code>を表し、文字列の最後の 2 個の単語にマッチします。<code>\1</code>, <code>\2</code>, ..., <code>\n</code> は正規表現のマッチ部分で使用することに注意してください。詳しくは下記の <a href="#special-backreference">\n</a> を参照してください。 置換部分で使用する際は <code>$1</code>, <code>$2</code>, ..., <code>$n</code> とする必要があります。例えば、 <code>'bar foo'.replace(/(...) (...)/, '$2 $1')</code>というように。<code>$&amp;</code> はマッチした文字列全体を意味します。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-non-capturing-parentheses" id="special-non-capturing-parentheses" name="special-non-capturing-parentheses"><code>(?:x)</code></a></td>
    <td>
     <p>'x' にマッチしますが、マッチした内容は記憶しません。この括弧は<em>非キャプチャリング（非格納）括弧</em>と呼ばれ、パターンをグルーピングして、正規表現演算子と一緒に使う際の部分正規表現式を定義することができます。 見本として式 <code>/(?:foo){1,2}/</code> を見てみましょう。式が <code>/foo{1,2}/</code>であれば、<code>{1,2}</code> の文字は 'foo' の最後の 'o' にのみ適用されます。非キャプチャリング括弧を使うと、<code>{1,2}</code> は'foo' という単語全体に適用されます。詳しい情報は、下記の<a href="#Using_Parentheses">括弧を使う</a>を見てください。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-lookahead" id="special-lookahead" name="special-lookahead"><code>x(?=y)</code></a></td>
    <td>
     <p>'x' に 'y' が続く場合のみ 'x' にマッチします。この特殊文字は先読みと呼ばれます。</p>

     <p>例えば、<code>/Jack(?=Sprat)/</code> は 'Jack' の後に 'Sprat' が続く場合のみ 'Jack' にマッチします。 <code>/Jack(?=Sprat|Frost)/</code> は 'Jack' の後ろに 'Sprat' または 'Frost' が続く場合のみ 'Jack' にマッチします。しかしながら、'Sprat' も 'Frost' もマッチの結果には表れません。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-negated-look-ahead" id="special-negated-look-ahead" name="special-negated-look-ahead"><code>x(?!y)</code></a></td>
    <td>
     <p>'x' に 'y' が続かない場合のみ 'x' にマッチします。これは否定先読みと呼ばれます。</p>

     <p>例えば、 <code>/\d+(?!\.)/</code> は後ろに小数点が続かない数値にマッチします。正規表現 <code>/\d+(?!\.)/.exec("3.141")</code> は'141' にマッチしますが '3.141' にはマッチしません。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-lookbehind" id="special-lookbehind" name="special-lookbehind"><code>(?&lt;=y)x</code></a></td>
    <td>
     <p><code><em>x</em></code> の前に <code>y</code> がある場合のみ<code><em>x</em></code>にマッチします。 これは後読みと呼ばれます。</p>

     <p>例えば、 <code>/(?&lt;=Jack)Sprat/</code> は "Sprat" の前に "Jack" がある場合にのみマッチし、<br>
      <code>/(?&lt;=Jack|Tom)Sprat/</code> は "Sprat" の前に "Jack" または "Tom" がある場合にのみマッチします。<br>
      しかしながら、"Jack"も "Tom" もマッチの結果には表れません。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-negative-lookbehind" id="special-negative-lookbehind" name="special-negative-lookbehind"><code>(?&lt;!y)x</code></a></td>
    <td>
     <p><code><em>x</em></code> の前に <code><em>y</em></code>がない場合のみ <code><em>x</em></code> にマッチします。これは否定後読みと呼ばれます。</p>

     <p>例えば、 <code>/(?&lt;!-)\d+/</code> は前にマイナス符号がない数値にのみマッチします。<br>
      <code>/(?&lt;!-)\d+/.exec('3')</code> は "3"にマッチしていますが、<br>
      <code>/(?&lt;!-)\d+/.exec('-3')</code> にマッチは見つかりません。なぜなら' -3' の前にはマイナス符号があるからです。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-or" id="special-or" name="special-or"><code>x|y</code></a></td>
    <td>
     <p>'x', または 'y' にマッチします。（'x' にマッチする必要はありません。）</p>

     <p>例えば、<code>/green|red/</code> は "green apple" の 'green' や "red apple." の 'red' にマッチします。'x' と 'y' の順番は重要です。例えば <code>a*|b</code> は"b" の空文字列にマッチしますが、 <code>b|a*</code> は同じ文字列の "b" にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-quantifier" id="special-quantifier" name="special-quantifier"><code>{n}</code></a></td>
    <td>直前の文字がちょうど n 回出現するものにマッチします。n には正の整数が入ります。<br>
     <br>
     例えば、 <code>/a{2}/</code> は "candy" の 'a' にはマッチしませんが、"caaandy" の最初の 2 個の a にはマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-quantifier" id="special-quantifier" name="special-quantifier"><code>{n,}</code></a></td>
    <td>
     <p>直前の式の少なくとも n 回の出現にマッチします。n には正の整数が入ります。</p>

     <p>例えば、 <code>/a{2,}/</code> は "aa", "aaaa", "aaaaa" にマッチしますが "a" にはマッチしません。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-quantifier-range" id="special-quantifier-range" name="special-quantifier-range"><code>{n,m}</code></a></td>
    <td>
     <p>直前の文字が少なくとも <code>n</code> 回、多くても <code>m</code> 回出現するものにマッチします。<code>n</code> および <code>m</code> には正の整数が入ります。<code>m</code> を省略した場合は ∞ とみなされます。</p>

     <p>例えば、 <code>/a{1,3}/</code> は "cndy" ではマッチせず、"candy," の 'a'、"caandy," の 最初の 2 個の a、"caaaaaaandy" の最初の 3 個の a にマッチします。"caaaaaaandy" では元の文字列に a が 4 個以上ありますが、マッチするのは "aaa" であることに注意してください。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-character-set" id="special-character-set" name="special-character-set"><code>[xyz]</code></a></td>
    <td>
     <p>文字集合を表します。このパターンでは、角括弧で囲まれた文字のいずれか 1 個にマッチします。対象の文字は<a href="/ja/docs/Web/JavaScript/Guide/Grammar_and_types#Using_special_characters_in_strings" title="JavaScript Guide: Grammar and types § Using special characters in strings">エスケープシーケンス</a>も含みます。 文字の集合内では、特殊文字 (例えばドット (<code>.</code>) やアスタリスク (<code>*</code>)) は特別な意味を持たないので、それらにエスケープは不要です。以下で例示するように、ハイフンを用いて文字の範囲を指定することも可能です。<br>
      <br>
      例えば <code>[abcd]</code> は <code>[a-d]</code> と同じです。これは "brisket" の 'b' や "city" の 'c' にマッチします。<code>/[a-z.]+/</code> および <code>/[\w.]+/</code> はどちらも、"test.i.ng" の全体にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-negated-character-set" id="special-negated-character-set" name="special-negated-character-set"><code>[^xyz]</code></a></td>
    <td>
     <p>文字集合の否定または補集合です。角括弧で囲まれた文字ではない文字にマッチします。ハイフンを用いて文字の範囲を指定することも可能です。文字集合パターンで動作するものすべてがこちらでも機能します。</p>

     <p>例えば、 <code>[^abc]</code> は <code>[^a-c]</code>と同じです。これは "brisket" の 'r' や "chop" の 'h' といった一番最初の該当文字にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-backspace" id="special-backspace" name="special-backspace"><code>[\b]</code></a></td>
    <td>後退文字（バックスペース、U+0008）にマッチします。 後退文字自体にマッチさせるには角括弧を使う必要があります。（<code>\b</code> と混同しないように。）</td>
   </tr>
   <tr>
    <td><a href="#special-word-boundary" id="special-word-boundary" name="special-word-boundary"><code>\b</code></a></td>
    <td>
     <p>単語の区切りにマッチします。単語の区切りは、単語構成文字と後に続く非単語構成文字の間、または非単語構成文字と後に続く単語構成文字の間、または文字列の先頭、または文字列の最後とマッチします。単語の区切りはマッチする「文字」ではありません。アンカーのように、単語の区切りはマッチした部分に含まれません。言い換えると、マッチした単語の区切りの長さは 0 です。(<code>[\b]</code> と混同してはいけません。)</p>

     <p>入力文字に "moon" を使用した例:<br>
      <code>/\bm/</code> はマッチします。これは `\b` が文字列の先頭に存在するからです。<br>
      <code>/oo\b/</code> の '\b' はマッチしません。これは '\b' の前後に単語構成文字があるためです。<br>
      <code>/oon\b/</code> の '\b' はマッチします。これは、文字列の終端であるためです。<br>
      <code>/\w\b\w/</code> の '\b' はどこにもマッチしないでしょう。これは、'\b' の前後に単語構成文字があるためです。</p>

     <div class="note">
     <p><strong>注記 :</strong> JavaScript の正規表現エンジンでは「{{原語併記("単語","word")}}」を構成する文字として <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.6">特定の文字集合</a>を定義しています。 この集合内にない文字は非単語構成文字と見なされます。この文字集合はかなり限定的なもので、ローマ字の大文字小文字のアルファベット、10 進数字とアンダースコアのみが含まれます。"é" や "ü" といった文字{{訳注("そして日本語を構成する文字たちも")}}、残念ながら、一般的な表意文字と同様に、単語の区切りのために非単語構成文字として扱われます。</p>
     </div>
    </td>
   </tr>
   <tr>
    <td><a href="#special-non-word-boundary" id="special-non-word-boundary" name="special-non-word-boundary"><code>\B</code></a></td>
    <td>
     <p>単語の区切り以外にマッチします。マッチするのは以下の場合です：</p>

     <ul>
      <li>文字列の先頭の文字の前</li>
      <li>文字列の終端の文字の後</li>
      <li>単語内の 2 文字の間</li>
      <li>2 つの単語ではない文字の間</li>
      <li>空文字列</li>
     </ul>

     <p>例えば、<code>/\B../</code> は "noonday" の 'oo' に、<code>/y\B./</code> は "possibly yesterday" の 'ye' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-control" id="special-control" name="special-control"><code>\c<em>X</em></code></a></td>
    <td>
     <p>文字列中の制御文字にマッチします。 <em>X</em> には A から Z のうち 1 文字が入ります。</p>

     <p>例えば、 <code>/\cM/</code> は文字列中の control-M (U+000D) にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-digit" id="special-digit" name="special-digit"><code>\d</code></a></td>
    <td>
     <p>数字にマッチします。<code>[0-9]</code> に相当します。</p>

     <p>例えば、 <code>/\d/</code> や <code>/[0-9]/</code> は "B2 is the suite number" の '2' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-non-digit" id="special-non-digit" name="special-non-digit"><code>\D</code></a></td>
    <td>
     <p>数字以外の文字にマッチします。<code>[^0-9]</code> に相当します。</p>

     <p>例えば、<code>/\D/</code> や<code>/[^0-9]/</code> は "B2 is the suite number" の 'B' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-form-feed" id="special-form-feed" name="special-form-feed"><code>\f</code></a></td>
    <td>改ページ (U+000C) にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-line-feed" id="special-line-feed" name="special-line-feed"><code>\n</code></a></td>
    <td>改行文字 (U+000A) にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-carriage-return" id="special-carriage-return" name="special-carriage-return"><code>\r</code></a></td>
    <td>復帰文字 (U+000D) にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-white-space" id="special-white-space" name="special-white-space"><code>\s</code></a></td>
    <td>
     <p>スペース、タブ、改ページ、改行を含むホワイトスペース文字にマッチします。<code>[ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​-\u200a​\u2028\u2029\u202f\u205f​\u3000\ufeff]</code> に相当します。</p>

     <p>例えば <code>/\s\w*/</code> は "foo bar" の ' bar' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-non-white-space" id="special-non-white-space" name="special-non-white-space"><code>\S</code></a></td>
    <td>
     <p>ホワイトスペース以外の文字にマッチします。 <code>[^ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code> に相当します。</p>

     <p>例えば、 <code>/\S*/</code> は "foo bar" の 'foo' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-tab" id="special-tab" name="special-tab"><code>\t</code></a></td>
    <td>タブ (U+0009) にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-vertical-tab" id="special-vertical-tab" name="special-vertical-tab"><code>\v</code></a></td>
    <td>垂直タブ (U+000B) にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-word" id="special-word" name="special-word"><code>\w</code></a></td>
    <td>
     <p>アンダースコアを含むどの英数字にもマッチします。<code>[A-Za-z0-9_]</code> に相当します。</p>

     <p>例えば <code>/\w/</code> は、"apple," の 'a' や "$5.28," の '5' や "3D" の '3' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-non-word" id="special-non-word" name="special-non-word"><code>\W</code></a></td>
    <td>
     <p>前述以外の文字にマッチします。<code>[^A-Za-z0-9_]</code> に相当します。</p>

     <p>例えば、<code>/\w/</code> や <code>/[^A-Za-z0-9_]/</code> は、"50%" の '%' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-backreference" id="special-backreference" name="special-backreference"><code>\<em>n</em></code></a></td>
    <td>
     <p><em>n</em> に正の整数が入る場合、正規表現内において <em>n</em> 番目の括弧の部分にマッチした最新の部分文字列への後方参照となります（括弧の数は左からカウントします）。</p>

     <p>例えば <code>/apple(,)\sorange\1/</code> は "apple, orange, cherry, peach" の 'apple, orange,' にマッチします。</p>
    </td>
   </tr>
   <tr>
    <td><a href="#special-null" id="special-null" name="special-null"><code>\0</code></a></td>
    <td>NULL 文字 (U+0000) にマッチします。この後ろに他の数字を続けてはいけません。<code>\0</code> の後に（0 から 7 までの）数字が続くと 8 進数の <a href="/ja/docs/Web/JavaScript/Guide/Grammar_and_types#Using_special_characters_in_strings" title="JavaScript Guide: Grammar and types § Using special characters in strings">エスケープシーケンス</a>となるからです。</td>
   </tr>
   <tr>
    <td><a href="#special-hex-escape" id="special-hex-escape" name="special-hex-escape"><code>\xhh</code></a></td>
    <td>hh（2 桁の 16 進数）コードからなる文字列にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-unicode-escape" id="special-unicode-escape" name="special-unicode-escape"><code>\uhhhh</code></a></td>
    <td>hhhh（4 桁の 16 進数）コードからなる文字列にマッチします。</td>
   </tr>
   <tr>
    <td><a href="#special-unicode-escape-es6" id="special-unicode-escape-es6" name="special-unicode-escape-es6"><code>\u{hhhh}</code></a></td>
    <td>(u フラグがセットされた時のみ) Unicode 値 hhhh (16 進数) からなる文字列にマッチします。</td>
   </tr>
  </tbody>
 </table>
 </dd>
 <dt></dt>
</dl>

<h3 id="Escaping" name="Escaping">エスケープする</h3>

<p>もし特殊な文字を使う必要があるのなら（例えば実際に * を検索したい場合）、その文字の前にバックスラッシュを付けてエスケープする必要があります。例えば、a と * と b が続くのを検索する場合、<code>/a\*b/</code> とします。これはバックスラッシュが * を特殊な文字ではなく、リテラルとして扱うようにエスケープしています。</p>

<p>同様に、もし正規表現リテラルを書いていてスラッシュ('/')とマッチさせる必要があるならば、スラッシュをエスケープする必要があります（そうしないとスラッシュがパターンを終了してしまいます）。例えば、"/example/"の文字列とそれに続く1つ以上のアルファベットを探すためには、<code>/\/example\/[a-z]+/i</code>　とします。各スラッシュ前のバックスラッシュが、スラッシュをリテラルにしています。</p>

<p>リテラルのバックスラッシュにマッチするためには、バックスラッシュをエスケープする必要があります。例えば、'C' は任意の文字である "C:\" という文字列にマッチするためには、<code>/[A-Z]:\\/</code>とします。最初のバックスラッシュはその後のバックスラッシュをエスケープし、この表現は単一のリテラルバックスラッシュを探します。</p>

<p>RegExp コンストラクタを文字列リテラルを引数に指定して利用する場合は、バックスラッシュは文字列リテラル内でのエスケープ文字であることを思い出してください。つまり、バックスラッシュを正規表現で用いるには文字列リテラルレベルでエスケープする必要があります。 <code>/a\*b/</code> と <code>new RegExp("a\\*b")</code> は、 'a' の次に '*'、その次に 'b' を探す同じ表現を作成します。</p>

<p>エスケープ文字がパターンに追加されてないなら、{{jsxref("String.replace")}} を使用して追加することができます:</p>

<pre class="brush: js notranslate">function escapeRegExp(string) {
  return string.replace(/[.*+?^=!:${}()|[\]\/\\]/g, '\\$&amp;'); // $&amp;はマッチした部分文字列全体を意味します
}</pre>

<p>正規表現の後の g はグローバルサーチを行うオプション/フラグで、全体の文字列を見てすべてのマッチを返します。下の{{anch("Advanced_Searching_With_Flags", "フラグを用いた高度な検索")}}に詳しく説明されています。</p>

<h3 id="Using_Parentheses" name="Using_Parentheses">括弧の使い方</h3>

<p>正規表現パターンの一部を括弧で囲むことで、マッチした部分文字列を記憶しておくことができます。いったん記憶されれば、後からその部分文字列を呼び出すことができます。これに関しては{{anch("Using_Parenthesized_Substring_Matches", "括弧で囲まれた部分文字列のマッチの使用")}}で説明しています。</p>

<p>例として <code>/Chapter (\d+)\.\d*/</code> というパターンを使い、エスケープ文字と特殊文字についても説明した上で、どのようにパターンの一部が記憶されるかを示します。これは 'Chapter ' という文字列に正確にマッチし、それに続く 1 文字以上の数字 （<code>\d</code> はいずれかの数字を、<code>+</code> は 1 回以上の繰り返しを意味します）、それに続く小数点（それ自体は特殊文字であり、小数点の前の \ はパターンが '.' という文字そのものを探すようにすることを意味します）、それに続く 0 文字以上の数字 （<code>\d</code> は数字を、<code>*</code> は 0 回以上の繰り返しを意味します）にマッチします。さらに、最初にマッチした数字の記憶に括弧が使われています。</p>

<p>このパターンは "Open Chapter 4.3, paragraph 6" という文字列で検索され、'4' が記憶されます。このパターンは "Chapter 3 and 4" では見つかりません。この文字列は '3' の後にピリオドがないからです。</p>

<p>マッチした部分を記憶させることなく部分文字列にマッチさせたい場合は、その括弧においてパターンの前に <code>?:</code> をつけてください。例えば <code>(?:\d+)</code> は 1 文字以上の数字にマッチしますが、マッチした文字列は記憶しません。</p>

<h2 id="Working_with_Regular_Expressions" name="Working_with_Regular_Expressions">JavaScriptでの正規表現の使い方</h2>

<p>正規表現は、<code>RegExp</code> の <code>test</code> および <code>exec</code> メソッド、<code>String</code> の <code>match</code>、<code>replace</code>、<code>search</code>、<code>split</code> メソッドとともに使用します。これらのメソッドの詳細は <a href="/ja/docs/JavaScript/Reference">JavaScript リファレンス</a>で説明しています。</p>

<table class="standard-table">
 <caption>正規表現を使用するメソッド</caption>
 <thead>
  <tr>
   <th scope="col">メソッド</th>
   <th scope="col">説明</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("RegExp.exec", "exec")}}</td>
   <td>文字列中で一致するものを検索する <code>RegExp</code> のメソッドです。結果情報の配列を返します。</td>
  </tr>
  <tr>
   <td>{{jsxref("RegExp.test", "test")}}</td>
   <td>文字列中で一致するものがあるかをテストする <code>RegExp</code> のメソッドです。true または false を返します。</td>
  </tr>
  <tr>
   <td>{{jsxref("String.match", "match")}}</td>
   <td>文字列中で一致するものを検索する <code>String</code> のメソッドです。結果情報の配列を返します。マッチしない場合は null を返します。</td>
  </tr>
  <tr>
   <td>{{jsxref("String.matchAll", "matchAll")}}</td>
   <td>キャプチャグループを含んだ、すべてのマッチをもつ iterator を返す <code>String</code> のメソッドです。 </td>
  </tr>
  <tr>
   <td>{{jsxref("String.search", "search")}}</td>
   <td>文字列中で一致するものがあるかをテストする <code>String</code> のメソッドです。マッチした場所のインデックスを返します。検索に失敗した場合は -1 を返します。</td>
  </tr>
  <tr>
   <td>{{jsxref("String.replace", "replace")}}</td>
   <td>文字列中で一致するものを検索し、マッチした部分文字列を別の部分文字列に置換する <code>String</code> のメソッドです。</td>
  </tr>
  <tr>
   <td>{{jsxref("String.split", "split")}}</td>
   <td>正規表現または固定文字列を用いて文字列を分割し、部分文字列の配列に入れる <code>String</code> のメソッドです。</td>
  </tr>
 </tbody>
</table>

<p>あるパターンが文字列に存在するかを知りたいときは、<code>test</code> または <code>search</code> メソッドを使用してください。詳細な情報が知りたいときは（実行時間が長くなりますが）<code>exec</code> または <code>match</code> メソッドを使用してください。<code>exec</code> や <code>match</code> を使用してマッチが成功した場合、これらのメソッドは配列を返し、また結びつけられた正規表現オブジェクトと定義済みオブジェクトである <code>RegExp</code> オブジェクトのプロパティを更新します。マッチが失敗すると、<code>exec</code> メソッドは <code>null</code>（<code>false</code> に変換します）を返します。</p>

<p>次の例では、<code>exec</code> メソッドを使用して文字列を検索します。</p>

<pre class="brush: js notranslate">var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
</pre>

<p>正規表現のプロパティにアクセスする必要がない場合は、次のスクリプトが <code>myArray</code> を作成する別の方法になります:</p>

<pre class="brush: js line-numbers notranslate">var myArray = /d(b+)d/g.exec('cdbbdbsbz'); // similar to "cdbbdbsbz".match(/d(b+)d/g); however,
    // the latter outputs Array [ "dbbd" ], while
    // /d(b+)d/g.exec('cdbbdbsbz') outputs Array [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ].</pre>

<p>(異なるふるまいの詳しい情報は {{anch("g-different-behaviors", "g フラグによる振る舞いの違い")}}を参照してください。)</p>

<p>ある文字列から正規表現を組み立てたい場合は、次のスクリプトのような方法があります:</p>

<pre class="brush: js notranslate">var myRe = new RegExp('d(b+)d', 'g');
var myArray = myRe.exec('cdbbdbsbz');
</pre>

<p>これらのスクリプトではマッチが成功すると、配列を返すとともに次表で示されるプロパティを更新します。</p>

<table class="standard-table">
 <caption>正規表現の実行結果</caption>
 <thead>
  <tr>
   <th scope="col">オブジェクト</th>
   <th scope="col">プロパティまたはインデックス</th>
   <th scope="col">説明</th>
   <th scope="col">この例の場合</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td rowspan="4"><code>myArray</code></td>
   <td></td>
   <td>マッチした文字列と、すべての記憶された部分文字列です。</td>
   <td><code>['dbbd', 'bb', index: 1, input: 'cdbbdbsbz']</code></td>
  </tr>
  <tr>
   <td><code>index</code></td>
   <td>入力文字列でマッチした位置を示す、0 から始まるインデックスです。</td>
   <td><code>1</code></td>
  </tr>
  <tr>
   <td><code>input</code></td>
   <td>元の文字列です。</td>
   <td><code>"cdbbdbsbz"</code></td>
  </tr>
  <tr>
   <td><code>[0]</code></td>
   <td>最後にマッチした文字列です。</td>
   <td><code>"dbbd"</code></td>
  </tr>
  <tr>
   <td rowspan="2"><code>myRe</code></td>
   <td><code>lastIndex</code></td>
   <td>次のマッチが始まるインデックスです。（このプロパティは、g オプションを用いる正規表現でのみセットされます。これについては{{anch("Advanced_Searching_With_Flags", "フラグを用いた高度な検索")}}で説明します。）</td>
   <td><code>5</code></td>
  </tr>
  <tr>
   <td><code>source</code></td>
   <td>パターンのテキストです。正規表現の実行時ではなく作成時に更新されます。</td>
   <td><code>"d(b+)d"</code></td>
  </tr>
 </tbody>
</table>

<p>この例の 2 つ目の形式で示したように、オブジェクト初期化子を使用して、変数に代入せずに正規表現を使うことができます。しかしながら、この方法では生成される正規表現はすべて、別の正規表現として作成されます。このため、変数に代入しないこの形式を使用する場合は、その正規表現のプロパティに後からアクセスすることができません。例えば、次のようなスクリプトを使用するとしましょう :</p>

<pre class="brush: js notranslate">var myRe = /d(b+)d/g;
var myArray = myRe.exec('cdbbdbsbz');
console.log('The value of lastIndex is ' + myRe.lastIndex);

// "The value of lastIndex is 5"
</pre>

<p>しかし、このスクリプトの場合は次のようになります:</p>

<pre class="brush: js line-numbers notranslate">var myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log('The value of lastIndex is ' + /d(b+)d/g.lastIndex);

// "The value of lastIndex is 0"</pre>

<p>この 2 つの文中の <code>/d(b+)d/g</code> は別の正規表現オブジェクトであり、そのためにそれぞれの <code>lastIndex</code> プロパティの値も異なるのです。オブジェクト初期化子で作成する正規表現のプロパティにアクセスする必要がある場合は、まずそれを変数に代入するようにしてください。</p>

<h3 id="Using_Parenthesized_Substring_Matches" name="Using_Parenthesized_Substring_Matches">括弧で囲まれた部分文字列のマッチの使用</h3>

<p>正規表現パターンに括弧を含めることで、対応するサブマッチが記憶されます。例えば <code>/a(b)c/</code> は 'abc' という文字列にマッチし、'b' が記憶されます。この括弧で囲まれた部分文字列のマッチは、<code>Array</code> の要素 <code>[1]</code>, ..., <code>[n]</code> を使用して呼び出すことができます。</p>

<p>括弧で囲まれた部分文字列は何個でも使用できます。返された配列には、見つかったものすべてが存在します。以下の例では、括弧で囲まれた部分文字列の使用法を説明します。</p>

<p>次のスクリプトは {{jsxref("String.replace", "replace()")}} メソッドを使用して文字列中の単語を入れ替えます。テキスト置き換えのために、スクリプトで <code>$1</code> と <code>$2</code> を使用して、最初とその次の括弧で囲まれた部分文字列のマッチを示しています。</p>

<pre class="brush: js notranslate">var re = /(\w+)\s(\w+)/;
var str = 'John Smith';
var newstr = str.replace(re, '$2, $1');
console.log(newstr);

// "Smith, John"
</pre>

<h3 id="Advanced_Searching_With_Flags" name="Advanced_Searching_With_Flags">フラグを用いた高度な検索</h3>

<p>正規表現には、グローバルな検索や大文字／小文字を区別しない検索を可能にする 4 種類のオプションフラグがあります。これらのフラグは、単独で使用することもまとめて使用することもできます。順番は問いません。フラグは正規表現の一部として含まれます。</p>

<table class="standard-table">
 <caption>正規表現フラグ</caption>
 <thead>
  <tr>
   <th scope="col">フラグ</th>
   <th scope="col">説明</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>g</code></td>
   <td>グローバルサーチ。</td>
  </tr>
  <tr>
   <td><code>i</code></td>
   <td>大文字・小文字を区別しない検索。</td>
  </tr>
  <tr>
   <td><code>m</code></td>
   <td>複数行検索。</td>
  </tr>
  <tr>
   <td><code>s</code></td>
   <td><code>.</code> を改行文字と一致するようにします。</td>
  </tr>
  <tr>
   <td><code>u</code></td>
   <td>"unicode"; パターンをユニコードのコードポイントの連続として扱う</td>
  </tr>
  <tr>
   <td><code>y</code></td>
   <td>対象文字列で最後に見つかったマッチの位置から検索を開始する{{原語併記("先頭固定","sticky")}} 検索を行います。{{jsxref("RegExp.sticky", "sticky")}} のページをご覧ください。</td>
  </tr>
 </tbody>
</table>

<p>フラグを正規表現に含めるには、次のようにしてください :</p>

<pre class="brush: js notranslate">var re = /pattern/flags;
</pre>

<p>または</p>

<pre class="brush: js notranslate">var re = new RegExp('pattern', 'flags');
</pre>

<p>フラグは正規表現を作る際になくてはならないものであることに注意してください。後から加えたり取り除いたりすることはできません。</p>

<p>例えば <code>re = /\w+\s/g</code> は、1 個以上の文字とそれに続くスペースを探す正規表現を作成します。また、正規表現は文字列全体を通してこの組み合わせを探します。</p>

<pre class="brush: js notranslate">var re = /\w+\s/g;
var str = 'fee fi fo fum';
var myArray = str.match(re);
console.log(myArray);

// ["fee ", "fi ", "fo "]
</pre>

<p>この例では次の行 :</p>

<pre class="brush: js notranslate">var re = /\w+\s/g;
</pre>

<p>を次の行 :</p>

<pre class="brush: js notranslate">var re = new RegExp('\\w+\\s', 'g');
</pre>

<p>に置き換えることができます。得られる結果は同じです。</p>

<p id="g-different-behaviors"><code>.exec()</code> メソッドが使われた時には '<strong><code>g</code></strong>' に関連したふるまいは異なります。("class" と "argument" の役割が反対になります: <code>.match()</code> の場合、文字クラス(やデータ型) がメソッドを持ち、正規表現は単なる引数で、<code>.exec()</code> の場合、正規表現がメソッドを持ち、文字は引数です。<em><code>str.match(re)</code></em> と <em><code>re.exec(str)</code></em> を比較します) '<code><strong>g</strong></code>' フラグが <strong><code>.exec()</code></strong> メソッドで使われる時は繰り返して進むためです。</p>

<pre class="brush: js line-numbers notranslate">var xArray; while(xArray = re.exec(str)) console.log(xArray);
// produces:
// ["fee ", index: 0, input: "fee fi fo fum"]
// ["fi ", index: 4, input: "fee fi fo fum"]
// ["fo ", index: 7, input: "fee fi fo fum"]</pre>

<p><code>m</code> フラグは複数行の入力文字列が複数行として扱われるように使われます。<code>m</code> が使われた場合、<code>^</code> と <code>$</code> は文字列全体の最初と最後の代わりに、入力文字列内のあらゆる行の開始と終了にマッチします。</p>

<h2 id="Examples" name="Examples">例</h2>

<p>以下では、正規表現の使用法をいくつか例示します。</p>

<h3 id="Changing_the_Order_in_an_Input_String" name="Changing_the_Order_in_an_Input_String">入力文字列の順序変更</h3>

<p>次の例では、正規表現の構造と <code>string.split()</code> および <code>string.replace()</code> の使用法を示します。空白、タブ、1 個のセミコロンで分割された名前（ファーストネームが先頭）からなる、大まかに整形された入力文字列をきれいにフォーマットします。最終的に名前の順序を逆転し（ラストネームが先頭）、リストをソートします。</p>

<pre class="brush: js line-numbers language-js notranslate">// 名前の文字列は複数の空白やタブを含む。
// また、ファーストネームとラストネームの間に複数の空白があることもある
var names = 'Orange Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ';

var output = ['---------- Original String\n', names + '\n'];

// 2 種類の正規表現パターンと、格納用の配列を用意する。
// 文字列を分割して配列の要素に収める。

// パターン: ホワイトスペースの 0 回以上の繰り返しのあとにセミコロン、そのあとにホワイトスペースの 0 回以上の繰り返し
var pattern = /\s*;\s*/;

// 上記のパターンで文字列を断片に分割し、
// nameList という配列に断片を格納する。
var nameList = names.split(pattern);

// 新たなパターン: 1 個以上の文字、1 個以上のホワイトスペース、1 個以上の文字
// 括弧を用いてパターンの断片を記憶する。
// 記憶した断片は後から参照される。
pattern = /(\w+)\s+(\w+)/;

// 処理された名前を格納する新しい配列。
var bySurnameList = [];

// 名前の配列を表示し、新しい配列にカンマ区切りで名前を
// ラストネーム、ファーストネームの順で格納する。
//
// replace メソッドはパターンにマッチしたものを除去し、
// 「2 番目の記憶文字列のあとにカンマとスペース、
// さらにその後に続く 1 番目の記憶文字列」に置き換える。
//
// 変数 $1 および $2 は、パターンにマッチさせた際に
// 記憶しておいた部分文字列を参照する

output.push('---------- After Split by Regular Expression');

var i, len;
for (i = 0, len = nameList.length; i &lt; len; i++){
  output.push(nameList[i]);
  bySurnameList[i] = nameList[i].replace(pattern, '$2, $1');
}

// 新しい配列を表示する。
output.push("---------- Names Reversed");
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

// ラストネームについてソートし、ソートした配列を表示する。
bySurnameList.sort();
output.push('---------- Sorted');
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

output.push('---------- End');

console.log(output.join('\n'));

// produces:
//
// ---------- Original String
//
// Orange Carrot ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand
//
// ---------- After Split by Regular Expression
// Orange Carrot
// Fred Barney
// Helen Rigby
// Bill Abel
// Chris Hand
// ---------- Names Reversed
// Carrot, Orange
// Barney, Fred
// Rigby, Helen
// Abel, Bill
// Hand, Chris
// ---------- Sorted
// Abel, Bill
// Barney, Fred
// Carrot, Orange
// Hand, Chris
// Rigby, Helen
// ---------- End

</pre>

<h3 id="Using_Special_Characters_to_Verify_Input" name="Using_Special_Characters_to_Verify_Input">特殊文字を用いた入力の確認</h3>

<p>次の例では、ユーザーは電話番号を入力します。ユーザーが "Check" ボタンを押すと、スクリプトがその番号の妥当性を確認します。その番号が正当である（正規表現で指定した文字の連続にマッチする）場合、スクリプトはユーザーへの感謝のメッセージを表示し、その番号を承認します。番号が正当でない場合は、その番号が妥当でないことをユーザーに通知します。</p>

<p>正規表現は、0 または 1 個の左括弧 <code>\(?</code>、その後に 3 個の数字 <code>\d{3}</code>、その後に 0 または 1 個の右括弧 <code>\)?</code>、その後、見つかった際に記憶される 1 個のダッシュ、スラッシュ、または小数点 <code>([-\/\.])</code>、その後に 3 個の数字 <code>\d{3}</code>、その後、記憶された 1 個のダッシュ、スラッシュ、または小数点のマッチ <code>\1</code>、その後に 4 個の数字 <code>\d{4}</code> を探します。</p>

<p>ユーザーが <code>Enter</code> ボタンを押した際に発動する <code>Change</code> イベントにより <code>RegExp.input</code> の値が設定されます。</p>

<h4 id="HTML">HTML</h4>

<pre class="brush: html notranslate">&lt;p&gt;
  電話番号（市外局番含む）を入力して "チェック" をクリックしてください。
  &lt;br&gt;
  適切な形式は ###-###-#### のようなものです。
&lt;/p&gt;
&lt;form action="#"&gt;
  &lt;input id="phone"&gt;
    &lt;button onclick="testInfo(document.getElementById('phone'));"&gt;チェック&lt;/button&gt;
&lt;/form&gt;</pre>

<h4 id="JavaScript">JavaScript</h4>

<pre class="brush: js notranslate">var re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;
function testInfo(phoneInput) {
  var OK = re.exec(phoneInput.value);
  if (!OK) {
    console.error(phoneInput.value + ' は市外局番付電話番号ではありません！');
  } else {
    console.log('ありがとう、あなたの電話番号は ' + OK[0]);}
} </pre>

<h4 id="結果">結果</h4>

<div>
<p>{{ EmbedLiveSample('Using_Special_Characters_to_Verify_Input', '', '', '', 'Web/JavaScript/Guide/Regular_Expressions') }}</p>

<h2 id="仕様">仕様</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">仕様</th>
   <th scope="col">策定状況</th>
   <th scope="col">コメント</th>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="ブラウザサポート">ブラウザサポート</h2>

<div>


<p>{{Compat("javascript.builtins.RegExp")}}</p>
</div>
</div>

<div>{{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}</div>