正規表現について（RegExp）

・	正規表現について
・	RegExp オブジェクトを作成する
・	RegExp クラスのプロパティについて
・	RegExp クラスのメソッドについて
・	正規表現の構文（パターン）について

前のページに戻る

正規表現について

■正規表現について

■正規表現とは？

テキスト文書に対して、パターンマッチを試みる、構文の一種です。

テキスト内を検索し、マッチした位置や文字列などを取得できます。

■ RegExp クラスについて

正規表現用のクラスです。

RegExp オブジェクトは、正規表現の構文１つ分に相当します。

上に戻る

RegExp オブジェクトを作成する

RegExp コンストラクタについて

正規表現リテラルについて

正規表現のフラグについて

■RegExp コンストラクタについて

new 演算子を使って、RegExp オブジェクトを作成します。

new RegExp ( "pattern" , "flags" ) :RegExp

第01引数(略可)	String	正規表現の構文（パターン）を文字列で指定する。
第01引数(略可)	String	正規表現のフラグを指定する。
戻り値	RegExp	新しい RegExp オブジェクトが得られる

■第01引数（パターン）

こちらで解説しています。

文字列リテラルを記述する際、エスケープが必要になる事に注意して下さい。

正規表現にもエスケープがあり、二重に施す事になります。

■第02引数（フラグ）

こちらで解説しています。

■作成例

RegExp オブジェクトを作成する


// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = new RegExp( "あいう" );

// 出力テスト
console.log(re);

フラグ付きの RegExp オブジェクトを作成する


// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = new RegExp( "あいう" , "gi" );

// 出力テスト
console.log(re);

■正規表現リテラルについて

正規表現リテラルを使って、RegExp オブジェクトを作成する事もできます。

『 "/" + (pattern) + "/" + (flags) 』と記述します。

pattern 部分には、正規表現の構文（パターン）を記述します。

flags 部分には、正規表現のフラグを記述します。（省略可能）

■作成例

RegExp オブジェクトを作成する


// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = /あいう/;

// 出力テスト
console.log(re);

フラグ付きの RegExp オブジェクトを作成する


// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = /あいう/gi;

// 出力テスト
console.log(re);

■ RegExp コンストラクタとの違いについて

正規表現リテラルを使用すると、純粋な構文を記述する事ができます。

文字列リテラル側のエスケープを考慮する必要がありません。

正規表現リテラル内では、『 / 』記号のエスケープが必須となります。

この場合、『 \/ 』と記述します。

■正規表現のフラグについて

■主要ブラウザで利用可能

フラグ	意味	説明
g	global	途中から検索を開始、繰り返しマッチなど
i	ignoreCase	大文字と小文字を区別しない
m	multiline	１行ごとに先頭『 ^ 』と終端『 $ 』を判別できる

■ ECMAScript 6 世代

フラグ	意味	説明
u	unicode	構文側に Unicode スカラ値表記がある場合、１文字分と認識する。
y	sticky	正規表現マッチの試行を、指定した位置のみに限定する（lastIndex にて指定）

■ g フラグについて（global）

テキストの途中から、検索を開始したい場合に指定します。

■検索の開始位置を指定する

lastIndex プロパティを使用します。

正規表現マッチを行う直前に、開始位置をセットします。

■終端位置（次回の開始位置）を取得する

lastIndex プロパティを使用します。

正規表現マッチに成功した場合、次回の開始位置が得られます。

正規表現マッチに失敗した場合、0 値が得られます。

■途中から検索を開始する例

テキストの途中から検索を開始する


// ------------------------------------------------------------
// 文字列を用意する
// ------------------------------------------------------------
var str = "○○▲▲○○○▲○○○○▲▲▲▲○";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（global フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "[▲]+" , "g" );


// ------------------------------------------------------------
// テキストの途中から検索を開始する
// ------------------------------------------------------------
// 開始位置を指定する
re.lastIndex = 0;

// 正規表現マッチを試みる
var m = re.exec( str );

// 終端位置を取得する（次回の開始位置）
console.log( re.lastIndex ); // 4

// 出力テスト
console.log(m); // { index:2 , "0":"▲▲" }


// ------------------------------------------------------------
// テキストの途中から検索を開始する
// ------------------------------------------------------------
// 開始位置を指定する
re.lastIndex = 10;

// 正規表現マッチを試みる
var m = re.exec( str );

// 終端位置を取得する（次回の開始位置）
console.log( re.lastIndex ); // 16

// 出力テスト
console.log(m); // { index:12 , "0":"▲▲▲▲" }

■繰り返し文を使って順次検索する例

繰り返し文を使って順次検索する


// ------------------------------------------------------------
// 文字列を用意する
// ------------------------------------------------------------
var str = "○○▲▲○○○▲○○○○▲▲▲▲○";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（global フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "[▲]+" , "g" );

// ------------------------------------------------------------
// 開始位置を指定する
// ------------------------------------------------------------
re.lastIndex = 0;

// ------------------------------------------------------------
// 繰り返し文を使って順次検索する
// ------------------------------------------------------------
while(true){

	// 開始位置
	var startIndex = re.lastIndex;

	// 正規表現マッチを試みる
	var m = re.exec( str );
	if(!m) break;

	// 終端位置を取得する（次回の開始位置）
	var lastIndex = re.lastIndex;

	// 出力テスト
	console.log("startIndex:" + startIndex);
	console.log("index:" + m.index);
	console.log("lastIndex:" + lastIndex);
	console.log("lastMatch:\"" + m[0] + "\"");
	console.log(" --- ");
}

■ y フラグについて（sticky）

正規表現マッチの試行を、指定した位置のみに限定したい場合に指定します。

このフラグは、ECMAScript 6 世代の機能です。

■検索の開始位置を指定する

lastIndex プロパティを使用します。

正規表現マッチを行う直前に、開始位置をセットします。

■終端位置を取得する

lastIndex プロパティを使用します。

正規表現マッチに成功した場合、終端位置が得られます。

正規表現マッチに失敗した場合、0 値が得られます。

■使用例

指定した位置のみに限定して正規表現マッチを試みる


// ------------------------------------------------------------
// 文字列を用意する
// ------------------------------------------------------------
var str = "あああいううう";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（sticky フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "あいう" , "y" );


// ------------------------------------------------------------
// 指定した位置のみに限定して正規表現マッチを試みる
// ------------------------------------------------------------
// 開始位置を指定する
re.lastIndex = 1;

// 正規表現マッチを試みる
var result = re.test( str );

// 出力テスト
console.log(result); // false


// ------------------------------------------------------------
// 指定した位置のみに限定して正規表現マッチを試みる
// ------------------------------------------------------------
// 開始位置を指定する
re.lastIndex = 2;

// 正規表現マッチを試みる
var result = re.test( str );

// 出力テスト
console.log(result); // true

上に戻る

RegExp クラスのプロパティについて

静的なプロパティについて

RegExp オブジェクトのプロパティについて

■静的なプロパティについて

RegExp クラスには、静的なプロパティが存在します。

古くから存在する仕様ですが、標準化されておらず非推奨です。

正規表現マッチの結果を取得する事ができます。

Perl 言語に似た感覚で取り扱えます。

正規表現マッチに成功した瞬間、結果は上書き更新されます。

最後に成功した正規表現マッチの結果１回分だけが残っています。古い結果は上書きされて消滅します。

例えば、不定な関数を実行した場合、関数内で正規表現マッチを利用されている可能性があるでしょう。

■正規表現マッチの結果を安全に取得するには？

RegExp.exec()、String.match() メソッドを使用します。

戻り値から、結果オブジェクトを取得する事ができます。

■静的なプロパティ一覧

プロパティ	型	説明
RegExp.$1	String	1 番目の丸括弧とマッチした文字列を取得する
RegExp.$2	String	2 番目の丸括弧とマッチした文字列を取得する
RegExp.$3	String	3 番目の丸括弧とマッチした文字列を取得する
RegExp.$4	String	4 番目の丸括弧とマッチした文字列を取得する
RegExp.$5	String	5 番目の丸括弧とマッチした文字列を取得する
RegExp.$6	String	6 番目の丸括弧とマッチした文字列を取得する
RegExp.$7	String	7 番目の丸括弧とマッチした文字列を取得する
RegExp.$8	String	8 番目の丸括弧とマッチした文字列を取得する
RegExp.$9	String	9 番目の丸括弧とマッチした文字列を取得する
RegExp.lastParen	String	最後の丸括弧とマッチした文字列を取得する
RegExp.lastMatch	String	マッチした文字列全体を取得する
RegExp.leftContext	String	最先頭から、マッチした直前までの文字列を取得する
RegExp.rightContext	String	マッチした直後から、最後尾までの文字列を取得する
RegExp.input	String	入力テキスト全体を取得する

プロパティ	型	説明
RegExp["$+"] (U+002b)	String	lastParen プロパティと同等
RegExp["$&"] (U+0026)	String	lastMatch プロパティと同等
RegExp["$`"] (U+0060)	String	leftContext プロパティと同等
RegExp["$'"] (U+0027)	String	rightContext プロパティと同等
RegExp["$_"] (U+005f)	String	input プロパティと同等

■使用例

静的なプロパティから、正規表現マッチの結果を取得する


// ------------------------------------------------------------
// 文字列を用意する
// ------------------------------------------------------------
var str = "あいうえおかきくけこさしすせそたちつてと";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re0 = new RegExp( "さしすせそ" , "" );
var re1 = new RegExp( "([か-こ]+)([さ-そ]+)" , "" );

// ------------------------------------------------------------
// 正規表現マッチを試みる（１回目）
// ------------------------------------------------------------
var m0 = str.match( re0 );

// ------------------------------------------------------------
// 静的なプロパティから結果を取得する（非推奨）
// ------------------------------------------------------------
console.log( RegExp.$1 ); // ""
console.log( RegExp.$2 ); // ""
console.log( RegExp.$3 ); // ""
console.log( RegExp.lastParen    ); // ""
console.log( RegExp.lastMatch    ); // "さしすせそ"
console.log( RegExp.leftContext  ); // "あいうえおかきくけこ"
console.log( RegExp.rightContext ); // "たちつてと"
console.log( RegExp.input        ); // "あいうえおかきくけこさしすせそたちつてと"

// ------------------------------------------------------------
// 正規表現マッチを試みる（２回目）
// ------------------------------------------------------------
var m1 = str.match( re1 );

// ------------------------------------------------------------
// 静的なプロパティから結果を取得する（非推奨）
// ------------------------------------------------------------
console.log( RegExp.$1 ); // "かきくけこ"
console.log( RegExp.$2 ); // "さしすせそ"
console.log( RegExp.$3 ); // ""
console.log( RegExp.lastParen    ); // "さしすせそ"
console.log( RegExp.lastMatch    ); // "かきくけこさしすせそ"
console.log( RegExp.leftContext  ); // "あいうえお"
console.log( RegExp.rightContext ); // "たちつてと"
console.log( RegExp.input        ); // "あいうえおかきくけこさしすせそたちつてと"

// ------------------------------------------------------------
// 戻り値から得られた結果を取得する（推奨）
// ------------------------------------------------------------
console.log( m0 );
console.log( m1 );

■ RegExp オブジェクトのプロパティについて

プロパティ	型	説明
source	String	正規表現構文として記述した文字列を取得する（変更不可）
flags	String	正規表現フラグとして記述した文字列を取得する（変更不可）（ES6世代）
global	Boolean	g フラグを指定すると true が得られる（変更不可）
ignoreCase	Boolean	i フラグを指定すると true が得られる（変更不可）
multiline	Boolean	m フラグを指定すると true が得られる（変更不可）
sticky	Boolean	y フラグを指定すると true が得られる（変更不可）（ES6世代）
unicode	Boolean	u フラグを指定すると true が得られる（変更不可）（ES6世代）

プロパティ	型	説明
lastIndex	Number	テキストの途中から検索を開始する場合、開始位置を指定する（gフラグ）マッチに成功した場合、終端位置が得られる（gフラグ）正規表現マッチの試行を、指定した位置のみに限定する（yフラグ）

■取得例

正規表現の各情報を取得する


// ------------------------------------------------------------
// 正規表現構文を用意する
// ------------------------------------------------------------
var source = "あいうえお";

// ------------------------------------------------------------
// 正規表現フラグを用意する
// ------------------------------------------------------------
var flags = "g" + "i" + "m";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = new RegExp( source , flags );

// ------------------------------------------------------------
// 各情報を取得する
// ------------------------------------------------------------
console.log( re.source ); // "あいうえお"
console.log( re.flags  ); // "gimuy"

console.log( re.global     ); // true（gフラグの有無）
console.log( re.ignoreCase ); // true（iフラグの有無）
console.log( re.multiline  ); // true（mフラグの有無）
console.log( re.unicode    ); // false（uフラグの有無）
console.log( re.sticky     ); // false（yフラグの有無）

■ lastIndex プロパティについて

フラグの指定によって、仕様が変化します。

■ g フラグを指定した場合（global）

こちらで解説しています。

■ y フラグを指定した場合（sticky）

こちらで解説しています。

上に戻る

RegExp クラスのメソッドについて

■正規表現関連のメソッド一覧

■ RegExp クラスのメソッド

メソッド	説明
test()	正規表現マッチを試み、単純な真偽結果を取得する。
exec()	正規表現マッチを試み、詳細な結果を取得する。

■ String クラスのメソッド

メソッド	説明
split()	指定したワードで文字列を分割し、結果を配列で取得する。
search()	文字列内を検索し、正規表現マッチした位置を取得する。
match()	文字列内を検索し、正規表現マッチした詳細な結果を取得する。
replace()	文字列を置換した結果を、新しい文字列として取得する。

■正規表現マッチを試み、単純な真偽結果を取得する

test() メソッドを使用します。

RegExp.test( "テキスト" ) :Boolean

第01引数(略可)	String	パターンマッチを試みたいテキストを文字列で指定する。
戻り値	Boolean	マッチに成功した場合 true、失敗した場合 false が得られる。

■正規表現マッチの結果について

戻り値から、単純な真偽結果を取得できます。

成功した場合、静的なプロパティから、詳細な結果を取得できます。（非推奨）

■途中から検索を開始するには？

こちらで解説しています。

■類似メソッドについて

String.search() などがあります。

■使用例

正規表現マッチを試み、単純な真偽結果を取得する


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "abcedfg 01234 あいうえお";


// ------------------------------------------------------------
// 正規表現マッチを試み、単純な真偽結果を取得する
// ------------------------------------------------------------
// RegExp オブジェクトを作成する
var re = /かきくけこ/;

// 正規表現マッチを試み、単純な真偽結果を取得する
var result = re.test( str );

// 出力テスト
console.log(result); // false


// ------------------------------------------------------------
// 正規表現マッチを試み、単純な真偽結果を取得する
// ------------------------------------------------------------
// RegExp オブジェクトを作成する
var re = new RegExp( "[0-9]+" , "" );

// 正規表現マッチを試み、単純な真偽結果を取得する
var result = re.test( str );

// 出力テスト
console.log(result); // true

テキストの途中から正規表現マッチを試みる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "01234 abcedfg 56789 あいうえお";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（global フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "[0-9]+" , "g" );

// ------------------------------------------------------------
// 開始位置を指定する
// ------------------------------------------------------------
re.lastIndex = 10;

// ------------------------------------------------------------
// 正規表現マッチを試み、単純な真偽結果を取得する
// ------------------------------------------------------------
var result = re.test( str );

// ------------------------------------------------------------
// 静的なプロパティから結果を取得する（非推奨）
// ------------------------------------------------------------
if(result){

	console.log( RegExp.lastMatch    ); // "56789"
	console.log( RegExp.leftContext  ); // "01234 abcedfg "
	console.log( RegExp.rightContext ); // " あいうえお"

}

■正規表現マッチを試み、詳細な結果を取得する

exec() メソッドを使用します。

RegExp.exec( "テキスト" ) :*

第01引数(略可)	String	パターンマッチを試みたいテキストを文字列で指定する。
戻り値	*	マッチした場合、結果オブジェクトが得られる。マッチしなかった場合は null

■戻り値（結果オブジェクト）

マッチした場合、結果オブジェクトが得られます。

マッチしなかった場合、null 値が得られます。

■途中から検索を開始するには？

こちらで解説しています。

■類似メソッドについて

String.match() などがあります。

■使用例

正規表現マッチを試み、詳細な結果を取得する


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "◇◇◇◇◇https://sub.example.com/△△△△△";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する
// ------------------------------------------------------------
var re = new RegExp( "(http|https)://([^/]+)/" , "" );

// ------------------------------------------------------------
// 正規表現マッチを試み、詳細な結果を取得する
// ------------------------------------------------------------
var m = re.exec( str );

// 出力テスト
console.log(m); // { index:5 , "0":"https://sub.example.com/" , "1":"https" , "2":"sub.example.com" }

テキストの途中から正規表現マッチを試みる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "01234 abcedfg 56789 あいうえお";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（global フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "[0-9]+" , "g" );

// ------------------------------------------------------------
// 開始位置を指定する
// ------------------------------------------------------------
re.lastIndex = 10;

// ------------------------------------------------------------
// 正規表現マッチを試み、詳細な結果を取得する
// ------------------------------------------------------------
var m = re.exec( str );

// 出力テスト
console.log(m); // { index:14 , "0":"56789" }

繰り返し文を使って順次検索する


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "01234 abcedfg 56789 あいうえお 135 vwxyz 876 かきくけこ";

// ------------------------------------------------------------
// RegExp オブジェクトを作成する（global フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "[0-9]+" , "g" );

// ------------------------------------------------------------
// 開始位置を指定する
// ------------------------------------------------------------
re.lastIndex = 0;

// ------------------------------------------------------------
// 繰り返し文を使って順次検索する
// ------------------------------------------------------------
while(true){

	// ------------------------------------------------------------
	// 正規表現マッチを試み、詳細な結果を取得する
	// ------------------------------------------------------------
	var m = re.exec( str );
	if(!m) break;

	// ------------------------------------------------------------
	// 出力テスト
	// ------------------------------------------------------------
	console.log(re.lastIndex);
	console.log(m);
}

■ RegExp.exec() メソッドの戻り値について

結果オブジェクトは、配列のように中身を取り出す事ができます。

0 番目には、マッチした全体の文字列が格納されています。

1 番目以降には、( ) 括弧内にてサブマッチした文字列が、順番に格納されています。

( ) 括弧の数に上限はありません。

その他には、以下のプロパティが存在します。

プロパティ	型	説明
index	Number	正規表現とマッチしたテキストの位置。
input	String	正規表現マッチを試みたテキスト全体。（入力データ）

上に戻る

正規表現の構文（パターン）について

■特殊パターン一覧

特別な動作をする、構文の一覧です。

ここで使われる記号は、メタ文字と呼ばれます。

■一文字分の表現

構文	解説
.	すべての文字とマッチする（改行コードは除く）	*
\d	「数字」とマッチする	*
\D	「数字」以外の文字とマッチする	*
\s	「スペース、タブ、改行」とマッチする	*
\S	「スペース、タブ、改行」以外の文字とマッチする	*
\w	「英数字、アンダースコア」とマッチする	*
\W	「英数字、アンダースコア」以外の文字とマッチする	*

構文	解説
[abcxyz0-9A-Z]	「列挙した文字」とマッチする	*
[^abcxyz0-9A-Z]	「列挙した文字」以外の文字とマッチする	*

構文	解説
\xFF	「Hex スカラ値 (ASCII)」の文字とマッチする	*
\uFFFF	「Unicode スカラ値 (UTF-16)」の文字とマッチする（uフラグが必要）	*
\u{1FFFFF}	「Unicode スカラ値 (UTF-32)」の文字とマッチする（uフラグが必要）	*

■グループ化

構文	解説
(表現)	カッコ内の表現をグループ化する。マッチした結果を記憶する。	*
(?:表現)	カッコ内の表現をグループ化する。マッチした結果を記憶しない。	*

■量指定子

構文	解説
表現?	直前の表現が 0 ～ 1 回繰り返される	*
表現*?	直前の表現が 0 回以上繰り返される（最短マッチ）	*
表現*	直前の表現が 0 回以上繰り返される（最長マッチ）	*
表現+?	直前の表現が 1 回以上繰り返される（最短マッチ）	*
表現+	直前の表現が 1 回以上繰り返される（最長マッチ）	*

構文	解説
表現{n}	直前の表現が n 回繰り返される	*
表現{m,n}?	直前の表現が m ～ n 回繰り返される（最短マッチ）	*
表現{m,n}	直前の表現が m ～ n 回繰り返される（最長マッチ）	*
表現{m,}?	直前の表現が m 回以上繰り返される（最短マッチ）	*
表現{m,}	直前の表現が m 回以上繰り返される（最長マッチ）	*

■選択肢

構文	解説
(表現\|表現\|表現)	OR 条件。縦線記号で区切った表現のどれかとマッチする	*

■境界

構文	解説
^表現	m フラグ無効の場合、テキスト全体の最先頭であると言明する m フラグ有効の場合、１行ごとの最先頭であると言明する	*
表現$	m フラグ無効の場合、テキスト全体の最後尾であると言明する m フラグ有効の場合、１行ごとの最後尾であると言明する	*
\b	「単語の境界（スペースやタブなど）」となる文字であると言明するマッチ試行時のみ考慮され、最終結果には含まれない	*
\B	「単語の境界（スペースやタブなど）」以外の文字であると言明するマッチ試行時のみ考慮され、最終結果には含まれない	*

■先読み言明

構文	解説
表現(?=肯定的言明)	任意の表現の直後に、肯定的な表現を言明する（肯定的先読み）マッチ試行時のみ考慮され、最終結果には含まれない	*
表現(?!否定的言明)	任意の表現の直後に、否定的な表現を言明する（否定的先読み）マッチ試行時のみ考慮され、最終結果には含まれない	*

■「１文字」の表現について

■指定の１文字を表現する

マッチさせたい１文字を、そのまま記述します。

エスケープ表記が必要な文字も存在します。

指定した１文字とマッチするか調べる


var str = "abcedfg あいうえお";

var m = str.match( /a/  ); // { index:0 , "0":"a" }
var m = str.match( /あ/ ); // { index:8 , "0":"あ" }
var m = str.match( /ん/ ); // null

■エスケープが必要な文字について

以下の文字は、エスケープ表記が必要です。

そのまま記述すると、特殊パターンとして機能する為、エスケープで回避します。

文字	エスケープ表記	備考
^	\^	必須
$	\$	必須
\	\\	必須
.	\.	必須
*	\*	必須
+	\+	必須
?	\?	必須
(	\(	必須
)	\)	必須
[	\[	必須
]	\]	必須
{	\{	必須
}	\}	必須
\|	\\|	必須

指定する文字	エスケープ表記	備考
/	\/	正規表現リテラル内なら必須

エスケープ表記が不要な場所もあります。（文字集合内など）

RegExp コンストラクタを使用する場合、エスケープを二重に施す必要があります。

エスケープ表記を使って、１文字とマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str0 = "http://sub.example.com/";
var str1 = "C:\\Users\\Desktop\\test(+).txt"; // 「\\」は「\」を表す（文字列リテラル内のエスケープ）

// ------------------------------------------------------------
// 正規表現リテラルの場合
// ------------------------------------------------------------
var m = str0.match( /\// ); // { index:5  , "0":"/" }
var m = str0.match( /\./ ); // { index:10 , "0":"." }
var m = str1.match( /\\/ ); // { index:2  , "0":"\" }
var m = str1.match( /\(/ ); // { index:21 , "0":"(" }
var m = str1.match( /\+/ ); // { index:22 , "0":"+" }

// ------------------------------------------------------------
// 文字列リテラルの場合（エスケープを二重に施す）
// ------------------------------------------------------------
var m = str0.match( new RegExp("\\/")  ); // { index:5  , "0":"/" }
var m = str0.match( new RegExp("\\.")  ); // { index:10 , "0":"." }
var m = str1.match( new RegExp("\\\\") ); // { index:2  , "0":"\" }
var m = str1.match( new RegExp("\\(")  ); // { index:21 , "0":"(" }
var m = str1.match( new RegExp("\\+")  ); // { index:22 , "0":"+" }

var m = str0.match( new RegExp("/") ); // スラッシュのエスケープは必須ではない

■「すべての文字」とマッチする一文字を表現する

ピリオド『 . 』を使用します。

ただし改行コードとはマッチしません。

ピリオド記号を使って、１文字とマッチするか調べる


var str = "あいうえおかきくけこ";

var m = str.match( /./ ); // { index:0 , "0":"あ" }

■文字クラスの一覧（一部抜粋）

構文	解説
\d	「数字」とマッチする
\D	「数字」以外の文字とマッチする
\s	「スペース、タブ、改行」とマッチする
\S	「スペース、タブ、改行」以外の文字とマッチする
\w	「英数字、アンダースコア」とマッチする
\W	「英数字、アンダースコア」以外の文字とマッチする

文字クラスを使って、１文字とマッチするか調べる


var str = "abcedfg 01234 あいうえお";

var m = str.match( /\d/ ); // { index:8 , "0":"0" }
var m = str.match( /\s/ ); // { index:7 , "0":" " }
var m = str.match( /\w/ ); // { index:0 , "0":"a" }

■「文字集合（文字セット）」を使って１文字を表現する

こちらで解説しています。

■「文字コード」を指定して１文字を表現する

構文	解説
\xFF	「Hex スカラ値 (ASCII)」の文字とマッチする
\uFFFF	「Unicode スカラ値 (UTF-16)」の文字とマッチする（uフラグが必要）
\u{1FFFFF}	「Unicode スカラ値 (UTF-32)」の文字とマッチする（uフラグが必要）

u フラグは、ECMAScript 6 世代の機能です。

文字コードを使って、１文字とマッチするか調べる


var str = "abcedfg あいうえお 😃😃😃";

var m = str.match( /\x61/ ); // { index:0 , "0":"a" }
var m = str.match( /\x66/ ); // { index:5 , "0":"f" }

var m = str.match( /\u0061/u       ); // { index:0  , "0":"a"  }
var m = str.match( /\u3042/u       ); // { index:8  , "0":"あ" }
var m = str.match( /\uD83D\uDE03/u ); // { index:14 , "0":"😃" } (サロゲートペア指定)

var m = str.match( /\u{61}/u    ); // { index:0  , "0":"a"  }
var m = str.match( /\u{3042}/u  ); // { index:8  , "0":"あ" }
var m = str.match( /\u{1F603}/u ); // { index:14 , "0":"😃" }

■「文字列」の表現について

■「１文字の表現」を組み合わせる

「１文字の表現」にて解説したパターンを、自由に組み合わせて記述します。

結果的に、文字列の表現となります。

任意のワードとマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "Cupcake Donut Eclair Froyo Gingerbread Honeycomb IceCreamSandwich";

// ------------------------------------------------------------
// 任意の単語とマッチするか調べる（大文字と小文字を区別する）
// ------------------------------------------------------------
var m = str.match( /Donut/     ); // { index:8  , "0":"Donut" }
var m = str.match( /Froyo/     ); // { index:21 , "0":"Froyo" }
var m = str.match( /Honeycomb/ ); // { index:39 , "0":"Honeycomb" }
var m = str.match( /KitKat/    ); // null

// ------------------------------------------------------------
// 任意の単語とマッチするか調べる（大文字と小文字を区別しない）
// ------------------------------------------------------------
var m = str.match( /cupcake/i ); // { index:0  , "0":"Cupcake" }
var m = str.match( /ECLAIR/i  ); // { index:14 , "0":"Eclair" }

マスク付きのワードとマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str0 = "initiate";
var str1 = "innovative";
var str2 = "wineglass";

// ------------------------------------------------------------
// マスク付きのワードとマッチするか調べる
// ------------------------------------------------------------
var re = /in...a./;
var m = str0.match(re); // { index:0 , "0":"initiat" }
var m = str1.match(re); // { index:0 , "0":"innovat" }
var m = str2.match(re); // { index:1 , "0":"ineglas" }

■「量指定子」と組み合わせる

こちらで解説しています。

番号付きのワードとマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str0 = "---Elephant0---";
var str1 = "----Pig001----";
var str2 = "-----Tiger365-----";

// ------------------------------------------------------------
// 番号付きのワードとマッチするか調べる
// ------------------------------------------------------------
var re = /[a-zA-Z]+[0-9]+/;
var m = str0.match(re); // { index:3 , "0":"Elephant0" }
var m = str1.match(re); // { index:4 , "0":"Pig001" }
var m = str2.match(re); // { index:5 , "0":"Tiger365" }

■任意の表現をグループ化して優先度を高める

こちらで解説しています。

■複数の表現を OR 条件で指定する

こちらで解説しています。

■文字集合（文字セット）について

■文字集合（文字セット）とは？

マッチさせたい文字の候補を、[ ] 括弧内に列挙する事ができます。

■構文について

構文	解説
[abcxyz0-9A-Z]	「列挙した文字」とマッチする
[^abcxyz0-9A-Z]	「列挙した文字」以外の文字とマッチする

■候補となる１文字を指定する

マッチさせたい１文字を、そのまま記述します。

エスケープ表記が必要な文字も存在します。

[ ] 括弧内に、マッチさせたい文字をそのまま記述する


var str = "abcedfg 01234 あいうえお";

var m = str.match( /[a]/  ); // { index:0  , "0":"a" }
var m = str.match( /[0]/  ); // { index:8  , "0":"0" }
var m = str.match( /[あ]/ ); // { index:14 , "0":"あ" }

var m = str.match( /[abcxyz]/      ); // { index:0  , "0":"a" }
var m = str.match( /[345789]/      ); // { index:11 , "0":"3" }
var m = str.match( /[あかさたな]/  ); // { index:14 , "0":"あ" }

■候補となる文字を範囲指定する

ハイフン『 - 』を使用します。

『 (開始文字) + "-" + (終了文字) 』と記述します。

マッチさせたい文字の候補を、範囲指定する


var str = "abcedfg 01234 あいうえお";

var m = str.match( /[0-9]/   ); // { index:8  , "0":"0" }
var m = str.match( /[a-z]/　 ); // { index:0　, "0":"a" }
var m = str.match( /[あ-ん]/ ); // { index:14 , "0":"あ" }

var m = str.match( /[0123-57-9]/  ); // { index:8  , "0":"0" }
var m = str.match( /[a-chijkx-z]/ ); // { index:0  , "0":"a" }
var m = str.match( /[あ-おか-こ]/ ); // { index:14 , "0":"あ" }

■ [ ] 括弧内でのエスケープについて

[ ] 括弧内では、メタ文字のエスケープは不要です。

ただし以下の文字は、エスケープが必要です。

文字	エスケープ表記	備考
\	\\	必須
]	\]	必須
-	\-	[ ] 括弧内の、最先頭や最後尾に記述した場合は不要

[ ] 括弧内にて、エスケープ表記が必要となる場合


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "^$\\.*+?()[]{}-/"; // 「\\」は「\」を表す（文字列リテラル内のエスケープ）

// ------------------------------------------------------------
// エスケープ表記が不要となる場合
// ------------------------------------------------------------
var m = str.match( /[.]/ ); // { index:3  , "0":"." }
var m = str.match( /[*]/ ); // { index:4  , "0":"*" }
var m = str.match( /[?]/ ); // { index:6  , "0":"?" }
var m = str.match( /[/]/ ); // { index:14 , "0":"/" }

// ------------------------------------------------------------
// エスケープ表記が必要となる場合
// ------------------------------------------------------------
var m = str.match( /[\\]/ ); // { index:2  , "0":"\" }
var m = str.match( /[\]]/ ); // { index:10 , "0":"]" }
var m = str.match( /[\-]/ ); // { index:13 , "0":"-" }

■表現の「量指定」について（Quantifier）

■量指定子とは？

「直前の表現」が、「任意の回数繰り返されたか」を表現する事ができます。

『 ? 』『 + 』『 * 』『 { } 』記号を使用します。

■量指定子パターン一覧

構文	解説
表現?	直前の表現が 0 ～ 1 回繰り返される
表現*?	直前の表現が 0 回以上繰り返される（最短マッチ）
表現*	直前の表現が 0 回以上繰り返される（最長マッチ）
表現+?	直前の表現が 1 回以上繰り返される（最短マッチ）
表現+	直前の表現が 1 回以上繰り返される（最長マッチ）

構文	解説
表現{n}	直前の表現が n 回繰り返される
表現{m,n}?	直前の表現が m ～ n 回繰り返される（最短マッチ）
表現{m,n}	直前の表現が m ～ n 回繰り返される（最長マッチ）
表現{m,}?	直前の表現が m 回以上繰り返される（最短マッチ）
表現{m,}	直前の表現が m 回以上繰り返される（最長マッチ）

■「直前の表現」の範囲について

直前の表現が、グループ化されている場合、文字列の表現と解釈します。

直前の表現が、グループ化されていない場合、１文字分の表現と解釈します。

直前の表現の範囲を確認する


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str0 = "ABCDDD";
var str1 = "ABCDABCD";

// ------------------------------------------------------------
// 「１文字分」の表現が繰り返しとなる場合
// ------------------------------------------------------------
var re = /ABCD+/; // "D" の繰り返し
var m = str0.match(re); // { index:0 , "0":"ABCDDD" }
var m = str1.match(re); // { index:0 , "0":"ABCD" }

// ------------------------------------------------------------
// 「グループ内」の表現が繰り返しとなる場合
// ------------------------------------------------------------
var re = /(ABCD)+/; // "ABCD" の繰り返し
var m = str0.match(re); // { index:0 , "0":"ABCD" }
var m = str1.match(re); // { index:0 , "0":"ABCDABCD" }

■「最長マッチ」と「最短マッチ」の違いについて

同じ開始位置で、複数のマッチしうるパターンが存在するとします。

最も長い結果を採用するのが「最長マッチ」です。

最も短い結果を採用するのが「最短マッチ」です。

候補の１文字を指定


var str = "ABCDEFGHIJKLMN";

var m = str.match( /[A-E]+?/ ); // { index:0 , "0":"A" }
var m = str.match( /[A-E]+/  ); // { index:0 , "0":"ABCDE" }

// 
// ここでマッチしうるパターンは 5 通りある
// 
// "ABCDE" ←最長
// "ABCD"
// "ABC"
// "AB"
// "A" ←最短

■「最短マッチ」の影響力について

最短マッチの結果は、必ずしも最短であるとは限りません。

最短マッチの指定は、正規表現マッチを失敗させるほどの影響力はありません。

最短でなかったとしても、マッチしうるパターンが見つかれば、それが結果となります。

最短マッチの指定は、必ずしも最短であるとは限らない


var str = "ABCDEFGHIJKLMN";

var m = str.match( /[A-E]+?/    ); // { index:0 , "0":"A" }
var m = str.match( /[A-E]+/     ); // { index:0 , "0":"ABCDE" }

var m = str.match( /[A-E]+?[F]/ ); // { index:0 , "0":"ABCDEF" }
var m = str.match( /[A-E]+[F]/  ); // { index:0 , "0":"ABCDEF" }

■表現の「グループ化」について

任意の表現をグループ化するには、( ) 括弧で囲みます。

( ) 括弧は、入れ子構造にする事もできます。

グループ化すると、文字列の表現としての範囲を主張できるでしょう。

( ) 括弧内の表現は、サブパターンと呼ばれます。

■グループ化パターン一覧

構文	解説
(表現)	カッコ内の表現をグループ化する。マッチした結果を記憶する。
(?:表現)	カッコ内の表現をグループ化する。マッチした結果を記憶しない。

■グループ化の影響について

量指定子の「直前の表現」の範囲が変化します。

選択肢の影響範囲が変化します。

■サブパターンマッチの結果ついて

( ) 括弧内にてマッチした結果は、後で個別に参照する事ができます。

静的なプロパティや、結果オブジェクトから取得できます。

■表現の「選択肢」について（Alternation）

■複数の表現を、OR 条件で指定する

複数の表現を、縦線『 | 』記号で区切ります。

『 ( 表現 | 表現 | 表現 ) 』と記述します。

( ) 括弧でグループ化しておくと、影響範囲を限定できます。

マッチ位置が同じだった場合、左側に記述した表現が優先的に採用されます。

３つのワードのどれかとマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str0 = "Belgium Denmark France";
var str1 = "Germany Ireland Italy";
var str2 = "Portugal Spain Sweden";

// ------------------------------------------------------------
// ３つのワードのどれかとマッチするか調べる
// ------------------------------------------------------------
var re = /(Finland|Germany|Spain)/;
var m = str0.match(re); // null
var m = str1.match(re); // { index:0 , "0":"Germany" }
var m = str2.match(re); // { index:9 , "0":"Spain" }

■表現の「言明」について（Assertion）

■言明（Assertion）とは？

正規表現マッチの検索時にのみ考慮される、特殊な表現を記述できます。

言明とマッチした部分は、最終的な結果に含まれません。

言明によって、現在の検索位置が進められる事もありません。

■境界パターン一覧

構文	解説
^表現	m フラグ無効の場合、テキスト全体の最先頭であると言明する m フラグ有効の場合、１行ごとの最先頭であると言明する
表現$	m フラグ無効の場合、テキスト全体の最後尾であると言明する m フラグ有効の場合、１行ごとの最後尾であると言明する
\b	「単語の境界（スペースやタブなど）」となる文字であると言明するマッチ試行時のみ考慮され、最終結果には含まれない
\B	「単語の境界（スペースやタブなど）」以外の文字であると言明するマッチ試行時のみ考慮され、最終結果には含まれない

テキスト全体の最先頭や最後尾とマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "---012--3456----789";

// ------------------------------------------------------------
// 最先頭であると言明したパターンとマッチするか調べる
// ------------------------------------------------------------
var re = /^[0-9]+/;
var m = str.match(re); // null

// ------------------------------------------------------------
// 最後尾であると言明したパターンとマッチするか調べる
// ------------------------------------------------------------
var re = /[0-9]+$/;
var m = str.match(re); // { index:16 , "0":"789" }

１行ごとの最先頭や最後尾とマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = 
	"---abc---xyz---\n" +
	"abc---xyz------\n" +
	"------abc---xyz\n" +
	"abc---------xyz";

// ------------------------------------------------------------
// １行ごとの最先頭であると言明したパターンとマッチするか調べる（multiline フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "^abc" , "gm" );
var m = re.exec(str); // { index:16 , "0":"abc" }
var m = re.exec(str); // { index:48 , "0":"abc" }
var m = re.exec(str); // null

// ------------------------------------------------------------
// １行ごとの最後尾であると言明したパターンとマッチするか調べる（multiline フラグを有効）
// ------------------------------------------------------------
var re = new RegExp( "xyz$" , "gm" );
var m = re.exec(str); // { index:44 , "0":"xyz" }
var m = re.exec(str); // { index:60 , "0":"xyz" }
var m = re.exec(str); // null

英単語とマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "I am not BOY.";

// ------------------------------------------------------------
// 英単語とマッチするか調べる
// ------------------------------------------------------------
var re = /\b[a-zA-Z]+\b/g;
var m = re.exec(str); // { index:0 , "0":"I" }
var m = re.exec(str); // { index:2 , "0":"am" }
var m = re.exec(str); // { index:5 , "0":"not" }
var m = re.exec(str); // { index:9 , "0":"BOY" }
var m = re.exec(str); // null

■先読み言明パターン一覧（Lookahead Assertion）

構文	解説
表現(?=肯定的言明)	任意の表現の直後に、肯定的な表現を言明する（肯定的先読み）マッチ試行時のみ考慮され、最終結果には含まれない
表現(?!否定的言明)	任意の表現の直後に、否定的な表現を言明する（否定的先読み）マッチ試行時のみ考慮され、最終結果には含まれない

先読み言明のマッチを確認する


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "---ビタミンＡ---ビタミンＢ１---ビタミンＢ２---ビタミンＣ---ビタミンＤ---ビタミンＥ---";

// ------------------------------------------------------------
// 肯定的先読みを使った表現とマッチするか調べる
// ------------------------------------------------------------
var re = /ビタミン(?=Ａ|Ｂ１|Ｂ２)/g;
var m = re.exec(str); // { index:3  , "0":"ビタミン" }（Ａ）
var m = re.exec(str); // { index:11 , "0":"ビタミン" }（Ｂ１）
var m = re.exec(str); // { index:20 , "0":"ビタミン" }（Ｂ２）
var m = re.exec(str); // null

// ------------------------------------------------------------
// 否定的先読みを使った表現とマッチするか調べる
// ------------------------------------------------------------
var re = /ビタミン(?!Ａ|Ｄ|Ｅ)/g;
var m = re.exec(str); // { index:11 , "0":"ビタミン" }（Ｂ１）
var m = re.exec(str); // { index:20 , "0":"ビタミン" }（Ｂ２）
var m = re.exec(str); // { index:29 , "0":"ビタミン" }（Ｃ）
var m = re.exec(str); // null

■先読み言明による否定について

肯定的先読みで検出できる構文を反転して、否定を実現できるとは限りません。

前後の表現に量指定子がある場合、期待しないマッチが含まれやすくなります。

繰り返し量を減らしていく事でマッチが見つかるのであれば、それが結果となるからです。

否定的先読みを先に記述して、絞り込む方法もあります。

この場合、否定的言明とマッチしても、スキップされるのは１文字分だけです。

先に否定的先読みを記述する事で、その表現が検出されないようにする


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "---『apple』------『banana』----『cherry』------『grape』-----『melon』-------『peach』---";

// ------------------------------------------------------------
// 『ワード』を検索する（先に否定的先読みを記述する事で、特定のワードを除外できる）
// ------------------------------------------------------------
var re = /『(?!banana)[a-z]+』/g;
var m = re.exec(str); // { index:3  , "0":"『apple』" }
var m = re.exec(str); // { index:28 , "0":"『cherry』" }
var m = re.exec(str); // { index:42 , "0":"『grape』" }
var m = re.exec(str); // { index:54 , "0":"『melon』" }
var m = re.exec(str); // { index:68 , "0":"『peach』" }
var m = re.exec(str); // null

// ------------------------------------------------------------
// 否定的先読みを、複数並べて記述する事もできる
// ------------------------------------------------------------
var re = /『(?!apple)(?!cherry)(?!melon)[a-z]+』/g;
var m = re.exec(str); // { index:16 , "0":"『banana』" }
var m = re.exec(str); // { index:42 , "0":"『grape』" }
var m = re.exec(str); // { index:68 , "0":"『peach』" }
var m = re.exec(str); // null

後続に数字が無いワードとマッチするか調べる


// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
var str = "---apple01------banana----cherry23------grape-----melon-------peach67---";

// ------------------------------------------------------------
// 後続に数字が有るワードとマッチするか調べる
// ------------------------------------------------------------
var re = /[a-z]+(?=[0-9]+)/g;
var m = re.exec(str); // { index:3  , "0":"apple" }
var m = re.exec(str); // { index:26 , "0":"cherry" }
var m = re.exec(str); // { index:62 , "0":"peach" }
var m = re.exec(str); // null

// ------------------------------------------------------------
// 後続に数字が無いワードとマッチするか調べる
// ------------------------------------------------------------
var re = /(?![a-z]+[0-9]+)[a-z]+/g;
var m = re.exec(str); // { index:16 , "0":"banana" }
var m = re.exec(str); // { index:40 , "0":"grape" }
var m = re.exec(str); // { index:50 , "0":"melon" }
var m = re.exec(str); // null

上に戻る

前のページに戻る