JavaScript プログラミング講座

 

正規表現について

 


■正規表現について

 
■正規表現とは?
 
テキスト文書に対して、パターンマッチを試みる、構文の一種です。
 
テキスト内を検索し、マッチした位置や文字列などを取得できます。
 

■ RegExp クラスについて

 
■ RegExp クラスについて
 
正規表現用のクラスです。
 
RegExp オブジェクトは、正規表現の構文1つ分に相当します。
 
 

 

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 1行ごとに先頭『 ^ 』と終端『 $ 』を判別できる
 
■ ECMAScript 6 世代
 
フラグ 意味 説明
u unicode 構文側に Unicode スカラ値表記がある場合、1文字分と認識する。
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 クラスには、静的なプロパティが存在します。
 
古くから存在する仕様ですが、標準化されておらず非推奨です。
 
正規表現マッチの結果を取得する事ができます。
 
Perl 言語に似た感覚で取り扱えます。
 
正規表現マッチに成功した瞬間、結果は上書き更新されます。
 
最後に成功した正規表現マッチの結果1回分だけが残っています。古い結果は上書きされて消滅します。
 
例えば、不定な関数を実行した場合、関数内で正規表現マッチを利用されている可能性があるでしょう。
 
■正規表現マッチの結果を安全に取得するには?
 
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( "([か-こ]+)([さ-そ]+)" , "" );

// ------------------------------------------------------------
// 正規表現マッチを試みる(1回目)
// ------------------------------------------------------------
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        ); // "あいうえおかきくけこさしすせそたちつてと"

// ------------------------------------------------------------
// 正規表現マッチを試みる(2回目)
// ------------------------------------------------------------
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 番目以降には、( ) 括弧内にてサブマッチした文字列が、順番に格納されています。
 
( ) 括弧の数に上限はありません。
 
その他には、以下のプロパティが存在します。
 
プロパティ説明
indexNumber正規表現とマッチしたテキストの位置。
inputString正規表現マッチを試みたテキスト全体。(入力データ)
 
 

 

正規表現の構文(パターン)について

 
 


■特殊パターン一覧

 
特別な動作をする、構文の一覧です。
 
ここで使われる記号は、メタ文字と呼ばれます。
 
■一文字分の表現
 
構文解説
.すべての文字とマッチする(改行コードは除く)*
\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 フラグ有効の場合、1行ごとの最先頭であると言明する
*
表現$m フラグ無効の場合、テキスト全体の最後尾であると言明する
m フラグ有効の場合、1行ごとの最後尾であると言明する
*
\b「単語の境界(スペースやタブなど)」となる文字であると言明する
マッチ試行時のみ考慮され、最終結果には含まれない
*
\B「単語の境界(スペースやタブなど)」以外の文字であると言明する
マッチ試行時のみ考慮され、最終結果には含まれない
*
 
■先読み言明
 
構文解説
表現(?=肯定的言明)任意の表現の直後に、肯定的な表現を言明する(肯定的先読み)
マッチ試行時のみ考慮され、最終結果には含まれない
*
表現(?!否定的言明)任意の表現の直後に、否定的な表現を言明する(否定的先読み)
マッチ試行時のみ考慮され、最終結果には含まれない
*
 

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

 
■指定の1文字を表現する
 
マッチさせたい1文字を、そのまま記述します。
 
エスケープ表記が必要な文字も存在します。
 
指定した1文字とマッチするか調べる

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 コンストラクタを使用する場合、エスケープを二重に施す必要があります。
 
エスケープ表記を使って、1文字とマッチするか調べる

// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
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("/") ); // スラッシュのエスケープは必須ではない
 
■「すべての文字」とマッチする一文字を表現する
 
ピリオド『 . 』 を使用します。
 
ただし改行コードとはマッチしません。
 
ピリオド記号を使って、1文字とマッチするか調べる

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

var m = str.match( /./ ); // { index:0 , "0":"あ" }
 
■文字クラスの一覧(一部抜粋)
 
構文解説
\d「数字」とマッチする
\D「数字」以外の文字とマッチする
\s「スペース、タブ、改行」とマッチする
\S「スペース、タブ、改行」以外の文字とマッチする
\w「英数字、アンダースコア」とマッチする
\W「英数字、アンダースコア」以外の文字とマッチする
 
文字クラスを使って、1文字とマッチするか調べる

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" }
 
■「文字集合(文字セット)」を使って1文字を表現する
 
こちらで解説しています。
 
■「文字コード」を指定して1文字を表現する
 
構文解説
\xFF「Hex スカラ値 (ASCII)」の文字とマッチする
\uFFFF「Unicode スカラ値 (UTF-16)」の文字とマッチする(uフラグが必要)
\u{1FFFFF}「Unicode スカラ値 (UTF-32)」の文字とマッチする(uフラグが必要)
 
u フラグは、ECMAScript 6 世代の機能です。
 
文字コードを使って、1文字とマッチするか調べる

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":"😃" }
 

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

 
■「1文字の表現」を組み合わせる
 
1文字の表現」にて解説したパターンを、自由に組み合わせて記述します。
 
結果的に、文字列の表現となります。
 
任意のワードとマッチするか調べる

// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
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]「列挙した文字」以外の文字とマッチする
 
■候補となる1文字を指定する
 
マッチさせたい1文字を、そのまま記述します。
 
エスケープ表記が必要な文字も存在します。
 
[ ] 括弧内に、マッチさせたい文字をそのまま記述する

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 回以上繰り返される(最長マッチ)
 
■「直前の表現」の範囲について
 
直前の表現が、グループ化されている場合、文字列の表現と解釈します。
 
直前の表現が、グループ化されていない場合、1文字分の表現と解釈します。
 
直前の表現の範囲を確認する

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

// ------------------------------------------------------------
// 「1文字分」の表現が繰り返しとなる場合
// ------------------------------------------------------------
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" }
 
■「最長マッチ」と「最短マッチ」の違いについて
 
同じ開始位置で、複数のマッチしうるパターンが存在するとします。
 
最も長い結果を採用するのが「最長マッチ」です。
 
最も短い結果を採用するのが「最短マッチ」です。
 
候補の1文字を指定

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 条件で指定する
 
複数の表現を、縦線『 | 』 記号で区切ります。
 
『 ( 表現 | 表現 | 表現 ) 』と記述します。
 
( ) 括弧でグループ化しておくと、影響範囲を限定できます。
 
マッチ位置が同じだった場合、左側に記述した表現が優先的に採用されます
 
3つのワードのどれかとマッチするか調べる

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

// ------------------------------------------------------------
// 3つのワードのどれかとマッチするか調べる
// ------------------------------------------------------------
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 フラグ有効の場合、1行ごとの最先頭であると言明する
表現$m フラグ無効の場合、テキスト全体の最後尾であると言明する
m フラグ有効の場合、1行ごとの最後尾であると言明する
\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" }
 
1行ごとの最先頭や最後尾とマッチするか調べる

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

// ------------------------------------------------------------
// 1行ごとの最先頭であると言明したパターンとマッチするか調べる(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

// ------------------------------------------------------------
// 1行ごとの最後尾であると言明したパターンとマッチするか調べる(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 = "---ビタミンA---ビタミンB1---ビタミンB2---ビタミンC---ビタミンD---ビタミンE---";

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

// ------------------------------------------------------------
// 否定的先読みを使った表現とマッチするか調べる
// ------------------------------------------------------------
var re = /ビタミン(?!A|D|E)/g;
var m = re.exec(str); // { index:11 , "0":"ビタミン" }(B1)
var m = re.exec(str); // { index:20 , "0":"ビタミン" }(B2)
var m = re.exec(str); // { index:29 , "0":"ビタミン" }(C)
var m = re.exec(str); // null
 
■先読み言明による否定について
 
肯定的先読みで検出できる構文を反転して、否定を実現できるとは限りません。
 
前後の表現に量指定子がある場合、期待しないマッチが含まれやすくなります。
 
繰り返し量を減らしていく事でマッチが見つかるのであれば、それが結果となるからです。
 
否定的先読みを先に記述して、絞り込む方法もあります。
 
この場合、否定的言明とマッチしても、スキップされるのは1文字分だけです。
 
先に否定的先読みを記述する事で、その表現が検出されないようにする

// ------------------------------------------------------------
// 適当な文字列を用意する
// ------------------------------------------------------------
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