【完全版】Javascriptで学ぶ正規表現の基本まとめ

JS
この記事は約26分で読めます。

 

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

基本的な知識があればカスタムコードを使って機能追加、目的を達成できるように作ってあります。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を凌駕する現役のプログラマチームによって監修されています。

サイト内のコードを共有する場合は、参照元として引用して下さいますと幸いです

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

●正規表現とは?

正規表現とは、文字列のパターンを表現するための記法です。複雑な文字列の検索やマッチング、置換などを効率的に行うことができます。

JavaScriptにおいても、正規表現は非常に強力なツールとして活用されています。

正規表現を使いこなせるようになると、コードの可読性や保守性が向上し、文字列処理のバグを減らすことができるでしょう。

また、正規表現を活用することで、これまで難しいと感じていた文字列操作も、簡潔に記述できるようになります。

○正規表現を使うメリット

正規表現を使うメリットは大きく分けて3つあります。

正規表現を効果的に使いこなすことで、JavaScriptでの文字列処理の幅が大きく広がります。コードの質と効率を高めるために、正規表現は欠かせないスキルと言えるでしょう。

□複雑なパターンマッチングが可能

正規表現を使えば、単純な文字列の一致だけでなく、特定の形式を満たす文字列や繰り返しパターンなど、より複雑な条件でマッチングができます。

これにより、柔軟性の高い文字列検索が実現できます。

□コードの可読性と保守性の向上

正規表現を活用することで、複雑な条件分岐や繰り返し処理を簡潔に記述できます。

コード量が減ることで、可読性が上がり、保守性も向上します。

正規表現に慣れれば、一目でその意図を理解できるようになるでしょう。

□処理速度の向上

正規表現はパターンマッチングに最適化されているため、一般的な文字列処理と比べて高速に処理できます。

特に大量のデータを扱う場合に、処理速度の差が顕著に現れます。

○JavaScriptでの正規表現の基本

JavaScriptで正規表現を使うには、正規表現リテラルまたはRegExpオブジェクトを使用します。

正規表現リテラルは、スラッシュ(/)で囲んだパターンで表現します。

一方、RegExpオブジェクトは、newキーワードを使って作成します。

// 正規表現リテラル
const regex1 = /pattern/;

// RegExpオブジェクト
const regex2 = new RegExp('pattern');

正規表現を使ってマッチングを行う場合は、String.prototype.match()メソッドを使用します。

このメソッドは、マッチした結果を配列で返します。

const str = 'Hello, World!';
const result = str.match(/Hello/);
console.log(result); // ["Hello"]

マッチングに成功した場合、結果の配列にはマッチした文字列が含まれます。

マッチングに失敗した場合は、nullが返されます。

●正規表現の基本的な使い方

正規表現を使いこなすためには、まずその基本的な使い方を理解することが重要です。

正規表現は特殊な記号や文字を組み合わせることで、柔軟かつ強力なパターンマッチングを実現します。

正規表現の基本要素として、メタ文字と修飾子があります。

メタ文字は特別な意味を持つ文字で、パターンを構成する上で欠かせません。

一方、修飾子はマッチングの動作を変更するためのオプションです。

これを適切に使い分けることで、目的に応じた正規表現パターンを作成できます。

○メタ文字の意味と使い方

メタ文字は正規表現の中で特別な意味を持つ文字です。

代表的なメタ文字とその意味は次の通りです。

  • .(ドット):任意の1文字にマッチ
  • *:直前の文字の0回以上の繰り返しにマッチ
  • +:直前の文字の1回以上の繰り返しにマッチ
  • ?:直前の文字の0回または1回の出現にマッチ
  • ^:文字列の先頭にマッチ
  • $:文字列の末尾にマッチ
  • []:角括弧内の任意の1文字にマッチ
  • [^]:角括弧内の文字以外の任意の1文字にマッチ
  • \:メタ文字をエスケープ

これらのメタ文字を組み合わせることで、柔軟なパターンマッチングが可能になります。

例えば、/a.c/という正規表現は、”a”で始まり任意の1文字を挟んで”c”で終わる文字列にマッチします。

○修飾子の種類と効果

修飾子は正規表現の動作を変更するためのオプションです。

JavaScriptでよく使われる修飾子には次のようなものがあります。

  • i:大文字と小文字を区別しない
  • g:グローバルマッチ(全てのマッチを検索)
  • m:マルチラインモード(^と$が各行の先頭と末尾にマッチ)

修飾子は正規表現リテラルの末尾に付けて使用します。

例えば、/hello/iという正規表現は、大文字と小文字を区別せずに”hello”にマッチします。

○サンプルコード1:基本的なパターンマッチング

次のサンプルコードでは、メタ文字を使った基本的なパターンマッチングを行っています。

const str = 'Hello, World! Hello, JavaScript!';

// "Hello"にマッチする正規表現
const regex1 = /Hello/;
console.log(str.match(regex1)); 
// 出力: ["Hello"]

// "Hello"の後に任意の文字が続く正規表現
const regex2 = /Hello.*/;
console.log(str.match(regex2)); 
// 出力: ["Hello, World! Hello, JavaScript!"]

// "Hello"の後に空白を挟んで大文字が続く正規表現
const regex3 = /Hello\s[A-Z]/g;
console.log(str.match(regex3)); 
// 出力: ["Hello, W", "Hello, J"]

○サンプルコード2:オプションを使ったマッチング

次のサンプルコードでは、修飾子を使ってマッチングの動作を変更しています。

const str = 'Hello, world! hello, JavaScript!';

// 大文字小文字を区別しない正規表現
const regex1 = /hello/i;
console.log(str.match(regex1)); 
// 出力: ["Hello"]

// 大文字小文字を区別せず、グローバルにマッチする正規表現
const regex2 = /hello/gi;
console.log(str.match(regex2)); 
// 出力: ["Hello", "hello"]

修飾子を使うことで、より柔軟なマッチングが可能になります。

i修飾子を使えば大文字と小文字を区別せずにマッチできますし、g修飾子を使えば全てのマッチを検索できます。

●文字クラスと量指定子

正規表現を使いこなす上で、文字クラスと量指定子は非常に重要な概念です。

文字クラスを使えば、特定の文字の集合を簡潔に表現できます。

一方、量指定子を使えば、マッチする文字の出現回数を指定できます。

適切に組み合わせることで、より柔軟で強力なパターンマッチングが可能になります。

JavaScriptでの文字列処理の幅を広げるためにも、文字クラスと量指定子の使い方を身につけておくことをおすすめします。

○文字クラスの記法と使い方

文字クラスは、角括弧[]で囲んだ文字の集合を表します。

例えば、[aeiou]は小文字の母音にマッチします。

また、[0-9]のようにハイフンを使えば、文字の範囲を表すこともできます。

文字クラスの中で^を使うと、指定した文字以外にマッチします。

例えば、[^0-9]は数字以外の文字にマッチします。

よく使われる文字クラスには、次のようなものがあります。

  • \d:数字([0-9]と同等)
  • \w:単語を構成する文字([A-Za-z0-9_]と同等)
  • \s:空白文字(スペース、タブ、改行など)

これらの文字クラスを使うことで、数字や単語、空白文字などを簡潔に表現できます。

○量指定子でマッチする文字数を指定

量指定子は、直前の文字やパターンの出現回数を指定するために使います。

ここでは代表的な量指定子とその意味をみてみましょう。

  • *:0回以上の繰り返し
  • +:1回以上の繰り返し
  • ?:0回または1回の出現
  • {n}:n回の繰り返し
  • {n,}:n回以上の繰り返し
  • {n,m}:n回以上m回以下の繰り返し

例えば、\d+は1つ以上の連続した数字にマッチします。

また、\w{3,8}は3文字以上8文字以下の単語にマッチします。

○サンプルコード3:文字クラスを使った検索

次のサンプルコードでは、文字クラスを使って特定の文字パターンを検索しています。

const str = 'Hello, World! 123 abc';

// 母音にマッチする正規表現
const regex1 = /[aeiou]/gi;
console.log(str.match(regex1));
// 出力: ["e", "o", "o", "a"]

// 数字にマッチする正規表現 
const regex2 = /\d/g;
console.log(str.match(regex2));
// 出力: ["1", "2", "3"]

// 英字と数字にマッチする正規表現
const regex3 = /\w/g; 
console.log(str.match(regex3));
// 出力: ["H", "e", "l", "l", "o", "W", "o", "r", "l", "d", "1", "2", "3", "a", "b", "c"]

regex1では、[aeiou]という文字クラスを使って母音にマッチする正規表現を作っています。

str.match(regex1)を実行すると、文字列内の母音が配列で返されます。

regex2では、\dという文字クラスを使って数字にマッチする正規表現を作っています。

str.match(regex2)を実行すると、文字列内の数字が配列で返されます。

regex3では、\wという文字クラスを使って英字と数字にマッチする正規表現を作っています。

str.match(regex3)を実行すると、文字列内の英字と数字が配列で返されます。

このように、文字クラスを使うことで特定の文字の集合にマッチする正規表現を簡潔に表現できます。

文字クラスを使いこなすことで、より柔軟で強力な文字列検索が可能になるでしょう。

○サンプルコード4:量指定子の活用例

次のサンプルコードでは、量指定子を使ってマッチする文字数を指定しています。

const str = 'Hello, World! 123 abc';

// 3文字以上の単語にマッチする正規表現
const regex1 = /\w{3,}/g;
console.log(str.match(regex1));
// 出力: ["Hello", "World", "123", "abc"] 

// 2桁以上4桁以下の数字にマッチする正規表現
const regex2 = /\d{2,4}/g;
console.log(str.match(regex2));
// 出力: ["123"]

regex1では、\w{3,}という正規表現を使って3文字以上の単語にマッチしています。

str.match(regex1)を実行すると、3文字以上の単語が配列で返されます。

regex2では、\d{2,4}という正規表現を使って2桁以上4桁以下の数字にマッチしています。

str.match(regex2)を実行すると、2桁以上4桁以下の数字が配列で返されます。

量指定子を使うことで、マッチする文字数を柔軟に指定できます。

文字クラスと組み合わせることで、より細かな条件でパターンマッチングができるようになります。

●グループ化とキャプチャ

正規表現でより複雑なパターンマッチングを行うには、グループ化とキャプチャが欠かせません。

グループ化を使えば、複数の文字やパターンをまとめて扱うことができます。

一方、キャプチャを使えば、マッチした文字列の一部を取得することができます。

グループ化とキャプチャを使いこなすことで、正規表現の表現力がさらに広がります。

この機能を活用することで、より柔軟で強力な文字列処理が可能になるでしょう。

JavaScriptでの文字列操作のスキルを向上させるためにも、グループ化とキャプチャの使い方をマスターしておくことをおすすめします。

○括弧を使ったグループ化

グループ化には、丸括弧()を使います。

丸括弧内の文字やパターンは、一つのまとまりとして扱われます。

これで、複数の文字やパターンに対して量指定子を適用したり、OR条件を指定したりできます。

例えば、(abc)+という正規表現は、”abc”という文字列の1回以上の繰り返しにマッチします。

また、(cat|dog)という正規表現は、”cat”または”dog”という文字列にマッチします。

グループ化を使うことで、正規表現パターンの可読性や再利用性が向上します。

複雑な条件を表現する際に、グループ化は非常に強力なツールとなります。

○キャプチャで部分一致した文字列を取得

キャプチャを使うと、正規表現にマッチした文字列の一部を取得することができます。

キャプチャは、グループ化の括弧()内で使用します。マッチした文字列は、特別な変数に格納され、後から参照することができます。

キャプチャを使う場合、括弧内の正規表現パターンにマッチした文字列が、順番に捕獲されます。

捕獲された文字列は、$1, $2のような特別な変数で参照できます。

例えば、(\d{4})-(\d{2})-(\d{2})という正規表現は、”YYYY-MM-DD”形式の日付文字列にマッチします。

この正規表現では、年、月、日がそれぞれキャプチャされます。

マッチした文字列の年は$1、月は$2、日は$3で参照できます。

○サンプルコード5:グループ化の例

次のサンプルコードでは、グループ化を使って文字列内の特定のパターンを検索しています。

const str = 'Hello, World! Hello, JavaScript!';

// "Hello"の後に任意の文字列が続く正規表現
const regex1 = /(Hello),.+/g;
console.log(str.match(regex1));
// 出力: ["Hello, World!", "Hello, JavaScript!"]

// "Hello"または"World"にマッチする正規表現
const regex2 = /(Hello|World)/g;
console.log(str.match(regex2));
// 出力: ["Hello", "World", "Hello"]

regex1では、”Hello”の後に任意の文字列が続くパターンを括弧でグループ化しています。

これにより、”Hello”で始まる文字列全体にマッチします。

regex2では、”Hello”または”World”にマッチするパターンを括弧でグループ化し、OR条件を指定しています。

これにより、”Hello”か”World”のいずれかにマッチします。

○サンプルコード6:キャプチャの使い方

次のサンプルコードでは、キャプチャを使ってマッチした文字列の一部を取得しています。

const str = '2023-05-18';

// "YYYY-MM-DD"形式の日付にマッチする正規表現
const regex = /(\d{4})-(\d{2})-(\d{2})/;
const match = str.match(regex);

console.log(match[0]); // 出力: "2023-05-18"
console.log(match[1]); // 出力: "2023"
console.log(match[2]); // 出力: "05"
console.log(match[3]); // 出力: "18"

この正規表現では、年、月、日をキャプチャしています。

match変数には、マッチした文字列とキャプチャした文字列が格納されます。

match[0]はマッチした文字列全体、match[1]は年、match[2]は月、match[3]は日を表します。

キャプチャを使うことで、正規表現にマッチした文字列の特定の部分を取得できます。

これは、文字列から特定の情報を抽出する際に非常に便利です。

●正規表現の関数とメソッド

JavaScriptには、正規表現を扱うための便利な関数やメソッドが用意されています。

使いこなすことで、正規表現を使った文字列操作がより効率的になります。

正規表現オブジェクトを使えば、正規表現パターンを動的に生成したり、正規表現のオプションを設定したりできます。

また、match()replace()split()といったメソッドを使えば、正規表現を使った文字列の検索、置換、分割などが簡単に行えます。

これらの関数とメソッドを使いこなすことで、正規表現の応用範囲がさらに広がるでしょう。

実践的な使用例を通して、正規表現の活用方法を身につけていきましょう。

○正規表現オブジェクトの使い方

JavaScriptでは、正規表現リテラルと正規表現オブジェクトの2つの方法で正規表現を表現できます。

正規表現オブジェクトは、RegExpコンストラクタを使って生成します。

const regex1 = /pattern/flags;  // 正規表現リテラル
const regex2 = new RegExp('pattern', 'flags');  // 正規表現オブジェクト

正規表現オブジェクトを使う利点は、正規表現パターンを動的に生成できることです。

変数や関数の戻り値を使って正規表現パターンを構築できるため、より柔軟な正規表現の扱いが可能になります。

また、正規表現オブジェクトには以下のようなプロパティやメソッドがあります。

  • source:正規表現パターンを表す文字列
  • flags:正規表現のフラグ(i、g、mなど)
  • test():正規表現とマッチするかどうかをテストするメソッド

これらを使うことで、正規表現の詳細な情報を取得したり、マッチングのテストを行ったりできます。

○match()、replace()、split()の使い方

JavaScriptの文字列には、正規表現を扱うための便利なメソッドが用意されています。

ここでは、match()replace()split()の使い方を見ていきましょう。

match()メソッドは、文字列内で正規表現にマッチする部分を検索し、マッチした文字列を配列で返します。

const str = 'Hello, World!';
const regex = /[A-Z]/g;
console.log(str.match(regex));  // 出力: ["H", "W"]

replace()メソッドは、文字列内で正規表現にマッチする部分を別の文字列で置換します。

const str = 'Hello, World!';
const regex = /Hello/;
console.log(str.replace(regex, 'Hi'));  // 出力: "Hi, World!"

split()メソッドは、文字列を正規表現にマッチする部分で分割し、分割された文字列を配列で返します。

const str = 'apple,banana,orange';
const regex = /,/;
console.log(str.split(regex));  // 出力: ["apple", "banana", "orange"]

これらのメソッドを使うことで、正規表現を使った文字列操作が簡単に行えます。

マッチした部分の検索、置換、分割など、様々な場面で活用できるでしょう。

○サンプルコード7:正規表現オブジェクトで検索

次のサンプルコードでは、正規表現オブジェクトを使って文字列内のパターンを検索しています。

const str = 'Hello, World! Hello, JavaScript!';
const patternStr = 'Hello';
const regex = new RegExp(patternStr, 'g');

console.log(str.match(regex));
// 出力: ["Hello", "Hello"]

ここでは、patternStr変数に正規表現パターンを指定し、その変数を使って正規表現オブジェクトを生成しています。

match()メソッドを使って、文字列内で正規表現にマッチする部分を検索し、マッチした文字列を配列で取得しています。

○サンプルコード8:文字列の置換

次のサンプルコードでは、正規表現を使って文字列内のパターンを置換しています。

const str = 'Hello, World! Hello, JavaScript!';
const regex = /Hello/g;

console.log(str.replace(regex, 'Hi'));
// 出力: "Hi, World! Hi, JavaScript!"

replace()メソッドを使って、文字列内で正規表現にマッチする部分を'Hi'という文字列で置換しています。

gフラグを使っているので、文字列内の全てのマッチ箇所が置換されます。

●正規表現の応用例

正規表現の基本的な使い方をマスターすれば、より実践的なシーンで正規表現を活用できるようになります。

ここでは、正規表現の応用例として、URLの検証とパスワードの強度チェックを取り上げます。

これらの例を通して、正規表現が実際の開発でどのように役立つのかを実感できるでしょう。

正規表現を使えば、複雑なパターンマッチングを簡潔に記述できるため、コードの可読性や保守性が向上します。

また、正規表現を使った検証ロジックを実装することで、ユーザー入力のチェックを効率的に行えます。

実務で正規表現を活用するためには、基本的な使い方だけでなく、応用的な使い方も身につけておくことが重要です。

ここで紹介する例を参考に、正規表現の応用力を高めていきましょう。

○URLの検証

Webアプリケーションを開発する際、ユーザーが入力したURLが正しい形式かどうかをチェックする必要があります。

正規表現を使えば、URLの形式を簡潔に表現し、バリデーションを行うことができます。

URLの基本的な形式は、プロトコル://ドメイン名/パスです。

これを正規表現で表すと、次のようになります。

^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$

この正規表現は、次の要素で構成されています。

  • ^:文字列の先頭
  • (https?:\/\/)?:プロトコル(httpまたはhttps)とスラッシュ(任意)
  • ([\da-z\.-]+):ドメイン名
  • \.:ドットエスケープ
  • ([a-z\.]{2,6}):トップレベルドメイン(2〜6文字)
  • ([\/\w \.-]*)*:パス
  • \/?:スラッシュ(任意)
  • $:文字列の末尾

この正規表現を使って、ユーザー入力をチェックすることで、有効なURLかどうかを判定できます。

○パスワード強度のチェック

セキュリティを考慮したWebアプリケーションでは、ユーザーが設定するパスワードの強度をチェックすることが重要です。

正規表現を使えば、パスワードが一定の条件を満たしているかどうかを簡単にチェックできます。

例えば、パスワードが次の条件を満たすことを要求する場合を考えてみましょう。

  • 8文字以上の長さ
  • 少なくとも1つの大文字を含む
  • 少なくとも1つの小文字を含む
  • 少なくとも1つの数字を含む

これらの条件を正規表現で表すと、次のようになります。

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

この正規表現は、この要素で構成されています。

  • ^:文字列の先頭
  • (?=.*[a-z]):少なくとも1つの小文字を含む(肯定先読み)
  • (?=.*[A-Z]):少なくとも1つの大文字を含む(肯定先読み)
  • (?=.*\d):少なくとも1つの数字を含む(肯定先読み)
  • [a-zA-Z\d]{8,}:8文字以上の英数字
  • $:文字列の末尾

この正規表現を使って、ユーザーが入力したパスワードをチェックすることで、強度の高いパスワードを要求できます。

○サンプルコード9:URLのバリデーション

次のサンプルコードでは、正規表現を使ってURLのバリデーションを行っています。

function isValidURL(url) {
  const regex = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/;
  return regex.test(url);
}

// 有効なURLの例
console.log(isValidURL('https://www.example.com')); // 出力: true
console.log(isValidURL('https://example.com/path/to/page')); // 出力: true

// 無効なURLの例
console.log(isValidURL('example.com')); // 出力: false
console.log(isValidURL('https://invalid.url')); // 出力: false

isValidURL関数では、URLの正規表現パターンを使ってバリデーションを行っています。

test()メソッドを使って、引数として渡されたURLが正規表現に一致するかどうかを判定しています。

有効なURLの例では、https://www.example.comhttp://example.com/path/to/pageがtrueと評価されます。

一方、無効なURLの例では、example.com(プロトコルがない)とhttps://invalid.url(トップレベルドメインが不正)がfalseと評価されます。

○サンプルコード10:パスワード強度判定

次のサンプルコードでは、正規表現を使ってパスワードの強度判定を行っています。

function isStrongPassword(password) {
  const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;
  return regex.test(password);
}

// 強力なパスワードの例
console.log(isStrongPassword('Password123')); // 出力: true
console.log(isStrongPassword('Str0ngP@ssw0rd')); // 出力: true

// 弱いパスワードの例
console.log(isStrongPassword('password')); // 出力: false
console.log(isStrongPassword('PASSWORD')); // 出力: false
console.log(isStrongPassword('12345678')); // 出力: false

isStrongPassword関数では、パスワードの強度条件を満たす正規表現パターンを使って判定を行っています。

test()メソッドを使って、引数として渡されたパスワードが正規表現に一致するかどうかを判定しています。

強力なパスワードの例では、Password123Str0ngP@ssw0rdがtrueと評価されます。

このパスワードは、8文字以上の長さがあり、大文字、小文字、数字をすべて含んでいます。

一方、弱いパスワードの例では、password(大文字と数字がない)、PASSWORD(小文字と数字がない)、12345678(英字がない)がfalseと評価されます。

●Tips & トラブルシューティング

正規表現を使いこなすためには、正しい使い方だけでなく、パフォーマンスやデバッグの方法も知っておく必要があります。

正規表現を適切に最適化することで、効率的な文字列処理が可能になります。

また、正規表現のデバッグ方法を身につけておけば、複雑なパターンマッチングでも問題を解決できるでしょう。

ここでは、正規表現を使う上での Tips とトラブルシューティングについて見ていきます。

理解することで、正規表現をより効果的に活用できるようになるはずです。

正規表現のパフォーマンスを意識し、デバッグ方法を身につけることで、実務でのコーディングの質と効率が向上するでしょう。

○サンプルコード11:正規表現のベンチマーク

次のサンプルコードでは、正規表現のパフォーマンスを測定するベンチマークを行っています。

function benchmarkRegex(regex, input, iterations) {
  const startTime = Date.now();

  for (let i = 0; i < iterations; i++) {
    regex.test(input);
  }

  const endTime = Date.now();
  const duration = (endTime - startTime) / 1000;

  console.log(`正規表現: ${regex}`);
  console.log(`入力文字列: ${input}`);
  console.log(`繰り返し回数: ${iterations}`);
  console.log(`実行時間: ${duration}秒`);
}

// ベンチマーク1: 固定文字列マッチ
const regex1 = /hello/;
const input1 = 'hello world';
benchmarkRegex(regex1, input1, 1000000);

// ベンチマーク2: キャプチャグループあり
const regex2 = /(hello) (world)/;
const input2 = 'hello world';
benchmarkRegex(regex2, input2, 1000000);

このコードでは、benchmarkRegex関数を定義しています。

この関数は、正規表現、入力文字列、繰り返し回数を受け取り、正規表現のマッチを指定回数実行します。

実行時間を計測し、結果を出力します。

ベンチマーク1では、固定文字列マッチの正規表現を使用しています。

ベンチマーク2では、キャプチャグループを含む正規表現を使用しています。

それぞれの正規表現について、100万回のマッチを行い、実行時間を比較しています。

実行結果を比較することで、正規表現のパフォーマンスの違いを確認できます。

このようなベンチマークを行うことで、正規表現の最適化ポイントを特定できるでしょう。

○サンプルコード12:正規表現のデバッグ

次のサンプルコードでは、正規表現をデバッグする方法を示しています。

function debugRegex(regex, input) {
  const matches = input.match(regex);

  console.log(`正規表現: ${regex}`);
  console.log(`入力文字列: ${input}`);
  console.log(`マッチ結果: ${matches}`);

  if (matches) {
    matches.forEach((match, index) => {
      console.log(`マッチ${index + 1}: ${match}`);
    });
  }
}

// デバッグ1: 単純なマッチ
const regex1 = /hello/;
const input1 = 'hello world';
debugRegex(regex1, input1);

// デバッグ2: キャプチャグループ
const regex2 = /(hello) (world)/;
const input2 = 'hello world hello universe';
debugRegex(regex2, input2);

このコードでは、debugRegex関数を定義しています。

この関数は、正規表現と入力文字列を受け取り、正規表現のマッチ結果をデバッグ出力します。

デバッグ1では、単純なマッチの正規表現を使用しています。

デバッグ2では、キャプチャグループを含む正規表現を使用しています。

それぞれの正規表現について、マッチ結果を詳細に出力しています。

マッチ結果を詳しく分析することで、正規表現が意図した通りにマッチしているかどうかを確認できます。

まとめ

JavaScriptの正規表現は、文字列処理を効率的に行うための強力なツールです。

本記事では、正規表現の基本概念から応用的な使い方まで、実践的なサンプルコードを交えて解説してきました。

正規表現を使いこなすことで、コードの可読性や保守性が向上し、複雑な文字列処理もスムーズに行えるようになります。

本記事で学んだ知識を活かして、JavaScriptでの文字列操作のスキルを磨いていきましょう。

正規表現の奥深さを楽しみながら、実践的なコーディングに役立てていきましょう。