正規表現 早見表｜記号一覧・言語別の違い・実用パターン（実行結果つき）

正規表現とは、「数字が3桁続く」「行の先頭が#」のような文字の並び方のルールを、記号で短く書き表す方法です。入力チェック、ログからの抽出、エディタでの一括置換など、言語やツールを問わず使われます。

ただし、正規表現は処理系（言語やコマンド）によって書き方が少しずつ違います。同じ \d が、grep では数字ではなく「d」という文字に一致したり、Python では全角数字にも一致したりします。この記事では、記号の一覧表に加えて、JavaScript（Node.js 22）・Python 3.14・Java 21・GNU grep 3.11（BRE/ERE/-P）・GNU sed 4.9 で実際に同じパターンを実行し、違いを比較表にまとめました。コピーして使える実用パターンは、一致する例・しない例の実行結果つきです。

正規表現の早見表（記号一覧）

まずは「. [] \d * + ? {} ^ $ () |」の11個を覚えれば、ほとんどの場面に対応できます。エスケープが必要な記号は . * + ? ^ $ ( ) [ ] { } | \ / です（/ は JavaScript のリテラルや sed の区切りに使うとき）。

処理系による書き方の違い（実行して確認）

同じパターンを各処理系で実行した結果です。○＝その書き方で動く、×＝使えない（エラー、または別の意味になる）です。

迷ったら「JavaScript・Java・grep -P はほぼ同じ、Python は名前付きグループだけ P が付く、grep と sed の標準は \d や最短一致が使えない」と覚えておくと便利です。grep・sed で \d を使いたいときは [0-9] と書くのが確実です。

実行したコード（JavaScript）

// node t.js（Node.js v22.22.2）
console.log("abc123".match(/\d+/)[0]);
console.log("2026-09-28".replace(/(?<y>\d+)-(?<m>\d+)-(?<d>\d+)/, "$<d>/$<m>/$<y>"));
console.log("price: 500".match(/(?<=price: ?)\d+/)[0]);   // 可変長の後読み
console.log("日本語abc".match(/^\p{L}+$/u)[0]);             // u フラグが必要
console.log("<a><b>".match(/<.+?>/)[0], "<a><b>".match(/<.+>/)[0]);
for (const src of ["(?P<y>\\d+)", "(?>a+)", "(?i)abc"]) {
  try { new RegExp(src); } catch (e) { console.log(e.message); }
}

123
28/09/2026
500
日本語abc
<a> <a><b>
Invalid regular expression: /(?P<y>\d+)/: Invalid group
Invalid regular expression: /(?>a+)/: Invalid group
Invalid regular expression: /(?i)abc/: Invalid group

実行したコード（Python 3.14）

import re
print(re.sub(r"(?P<y>\d+)-(?P<m>\d+)-(?P<d>\d+)", r"\g<d>/\g<m>/\g<y>", "2026-09-28"))
print(re.search(r"\d", "１"))                 # 全角数字にも一致する
print(re.search(r"\d", "１", re.ASCII))       # ASCII フラグで半角のみ
for p in [r"(?<y>\d+)", r"(?<=price: ?)\d+", r"\p{L}+"]:
    try:
        re.compile(p)
    except re.error as e:
        print(p, "->", e)

28/09/2026
<re.Match object; span=(0, 1), match='１'>
None
(?<y>\d+) -> unknown extension ?<y at position 1
(?<=price: ?)\d+ -> look-behind requires fixed-width pattern
\p{L}+ -> bad escape \p at position 0

Python の標準 re は (?<name>) と \p{...} に対応していません（3.11 と 3.14 の両方で確認）。Unicode プロパティを使いたいときは、外部パッケージの regex を使う方法があります。

実行したコード（Java 21）

// java -Dstdout.encoding=UTF-8 T.java
import java.util.regex.*;

public class T {
    public static void main(String[] args) {
        System.out.println("2026-09-28".replaceAll("(?<y>\\d+)-(?<m>\\d+)-(?<d>\\d+)", "${d}/${m}/${y}"));
        Matcher m = Pattern.compile("\\p{IsHan}+").matcher("漢字かな");
        if (m.find()) System.out.println(m.group());
        System.out.println("123abc".matches("\\d+"));                       // 全体一致
        System.out.println(Pattern.compile("\\d+").matcher("123abc").find()); // 部分一致
        System.out.println("price=PRICE".replaceAll("PRICE", Matcher.quoteReplacement("$5")));
        System.out.println("price=PRICE".replaceAll("PRICE", "$5"));        // $ がグループ参照と解釈される
    }
}

28/09/2026
漢字
false
true
price=$5
Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 5

Java では matches() が文字列全体、find() が一部分の一致です。置換文字列に $ や \ を含めるときは Matcher.quoteReplacement() で囲むと、そのままの文字として扱われます。

実行したコマンド（grep・sed）

$ echo 'abc123 d' | grep -o '\d\+'          # BRE の \d は「d」
d
$ echo 'abc123 d' | grep -oP '\d+'          # -P なら数字
123
$ echo 'aa+' | grep -o 'a+'                 # BRE の + はただの文字
a+
$ echo 'aa+' | grep -o 'a\+'                # BRE で「1回以上」は \+
aa
$ echo '<a><b>' | grep -oE '<.+?>'          # ERE は最短一致にならない
<a><b>
$ echo '<a><b>' | grep -oP '<.+?>'
<a>
<b>
$ echo 'price: 500' | grep -oP '(?<=price: ?)\d+'
grep: lookbehind assertion is not fixed length
$ echo 'price: 500' | grep -oP 'price: ?\K\d+'   # \K で「ここより前は結果に含めない」
500
$ echo 'abc' | sed -E 's/a(?=b)/X/'
sed: -e expression #1, char 11: Invalid preceding regular expression
$ echo '<a><b>' | sed -E 's/<[^>]+>/X/'     # 最短一致の代わりに否定クラス
X<b>

grep -P で長さが変わる後読みを使いたいときは \K が便利です。sed で最短一致をしたいときは、<.+?> の代わりに <[^>]+>（> 以外の文字の繰り返し）と書くと同じ結果になります。

グループ・後方参照・先読み後読みの使い方

キャプチャ・非キャプチャ・名前付き

const m = "2026-09-28".match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
console.log(m.groups.year, m.groups.month, m.groups.day);

2026 09 28

取り出す必要がないグループは (?:...) にすると、番号がずれにくくなり、意図も伝わりやすくなります。

後方参照：同じ文字の繰り返しを見つける

import re
print(re.search(r"\b(\w+)\s+\1\b", "this is is a pen").group(0))
print(re.search(r"\b(\w+)\s+\1\b", "this is a pen"))

is is
None

先読み・後読み：条件だけ確かめて、結果には含めない

先読み・後読みは「その位置の前後に何があるかを確認するだけで、文字は消費しない」書き方です。

console.log("100円と200ドル".match(/\d+(?=円)/)[0]);
console.log("1234567".replace(/\B(?=(\d{3})+(?!\d))/g, ","));

100
1,234,567

フラグ一覧（言語別）

複数行の文字列で ^ $ を各行に効かせたいときは m フラグが必要です。

import re
print(re.findall(r"^\w\d$", "a1\nb2", re.M))
print(re.findall(r"^\w\d$", "a1\nb2"))

['a1', 'b2']
[]

実用パターン集（コピペ用）

どの言語でも同じ結果になるよう、\d ではなく [0-9] で書いています（Python の \d は全角数字にも一致するため）。

郵便番号        ^[0-9]{3}-?[0-9]{4}$
電話（ハイフンあり） ^0[0-9]{1,4}-[0-9]{1,4}-[0-9]{3,4}$
電話（数字のみ）  ^0[0-9]{9,10}$
日付 YYYY-MM-DD  ^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$
時刻 HH:MM(:SS)  ^([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$
URL（http/https） ^https?://[A-Za-z0-9.-]+(:[0-9]+)?(/[^\s]*)?$
IPv4            ^((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])$
半角英数字のみ    ^[A-Za-z0-9]+$
カラーコード      ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$
パスワード強度    ^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[!-~]{8,64}$
画像の拡張子      \.(jpe?g|png|gif)$      ← i フラグ付き
同じ単語の連続    \b(\w+)\s+\1\b
半角カタカナ      [ｦ-ﾟ]

一致する / しないの実行結果

上のパターンを JavaScript（Node.js 22）・Python 3.14・Java 21 で同じ入力に対して実行しました。3つの処理系で結果はすべて同じでした（o＝一致、x＝不一致）。

読み取っておきたいポイントです。

• 日付パターンは 2026-02-30 も通ります。正規表現は「形」だけを確かめるので、存在する日付かどうかは日付ライブラリで確認します。
• 電話番号は「形のチェック」と「桁数のチェック」を分けると正確になります。03-1234-567 は形としては通りますが、ハイフンを除くと9桁なので「数字のみ」のパターンで x になります。
• パスワード強度は先読みを3つ並べて「小文字・大文字・数字をそれぞれ1文字以上」を表しています。[!-~] は ASCII の記号・英数字（空白を除く）です。
• メールアドレスと日本語（ひらがな・カタカナ・漢字）の判定は、それぞれ専用の記事で詳しく扱っています。

検証に使ったコード（JavaScript）

// node run.js
const tests = [
  ["郵便番号", /^[0-9]{3}-?[0-9]{4}$/, ["100-0001", "1000001", "100-001", "１００-０００１"]],
  ["日付", /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/, ["2026-09-28", "2026-02-30", "2026-13-01"]],
  ["パスワード", /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[!-~]{8,64}$/, ["Passw0rd", "password1", "Pa1"]],
];
for (const [name, re, inputs] of tests) {
  console.log(name, inputs.map(s => `${s}:${re.test(s) ? "o" : "x"}`).join(" "));
}

郵便番号 100-0001:o 1000001:o 100-001:x １００-０００１:x
日付 2026-09-28:o 2026-02-30:o 2026-13-01:x
パスワード Passw0rd:o password1:x Pa1:x

置換で使う実用パターン

実行結果（3言語）です。先頭が全角スペース、末尾がタブの文字列で試しています。

const s = "　  注文  番号 \t";
console.log(JSON.stringify(s.replace(/^\s+|\s+$/g, "")));
console.log(JSON.stringify(s.replace(/\s+/g, " ").trim()));
console.log("007".replace(/^0+(?=\d)/, ""), "000".replace(/^0+(?=\d)/, ""));
console.log("1234.56789".replace(/\B(?=(\d{3})+(?!\d))/g, ","));   // 小数部にも入ってしまう
const [i, d] = "1234.56789".split(".");
console.log(i.replace(/\B(?=(\d{3})+(?!\d))/g, ",") + "." + d);    // 整数部だけに適用

"注文  番号"
"注文 番号"
7 0
1,234.56,789
1,234.56789

String s = "　  注文  番号 \t";
System.out.println("[" + s.replaceAll("^\\s+|\\s+$", "") + "]");
System.out.println("[" + s.replaceAll("(?U)^\\s+|\\s+$", "") + "]");
System.out.println("[" + s.strip() + "]");

[　  注文  番号]
[注文  番号]
[注文  番号]

Java の \s は既定では全角スペースに一致しません。(?U) を付けるか、String.strip() を使うと全角スペースも取り除けます。JavaScript と Python の \s は全角スペースにも一致しました。

3桁区切りは小数を含むと小数部にもカンマが入ります。整数部だけに適用するか、JavaScript なら toLocaleString()、Python なら f"{n:,}" のような数値の書式機能を使うと確実です。

よくある落とし穴と直し方

1. . が改行に一致しない

import re
print(re.search(r"a.b", "a\nb"))
print(re.search(r"a.b", "a\nb", re.S))

None
<re.Match object; span=(0, 3), match='a\nb'>

. は既定で改行以外の1文字です。改行もまたぎたいときは s フラグ（Python は re.S、Java は DOTALL）を付けるか、[\s\S] と書きます。

2. 貪欲マッチで取りすぎる

最短一致が使えない grep・sed では、否定の文字クラス [^>] を使う書き方が便利です。処理もシンプルで速く、どの処理系でも同じ結果になります。

3. エスケープ忘れ

console.log("a.b.c".replace(/./g, "-"));    // . は「任意の1文字」
console.log("a.b.c".replace(/\./g, "-"));   // \. でドットそのもの
console.log("a.b.c".replaceAll(".", "-"));  // 文字列で渡すと正規表現にならない

-----
a-b-c
a-b-c

ユーザーの入力を正規表現に埋め込むときは、エスケープ関数を通します。Python は re.escape()、Java は Pattern.quote() が使えます。

4. ^ $ が「文字列全体」か「各行」か

さらに、全体一致を確認するつもりで部分一致の関数を使うと、余分な文字が付いていても通ります。

import re
print(re.match(r"\d+", "123abc"))
print(re.fullmatch(r"\d+", "123abc"))

<re.Match object; span=(0, 3), match='123'>
None

5. POSIX 文字クラスを他の言語で書くと別の意味になる

[[:digit:]] は grep・sed の書き方です。JavaScript では「[ : d i g t のどれか」の後に ] が続く、という別のパターンとして解釈され、エラーにもなりません（"ab12" に一致しないことを確認）。Python では FutureWarning: Possible nested set が表示されました。言語側では \d や [0-9] を使います。

6. 複雑な繰り返しの入れ子で処理が長引く

(a+)+$ のように繰り返しの中にさらに繰り返しを入れると、一致しない入力で処理時間が急に長くなることがあります（ReDoS と呼ばれます）。入れ子を避ける、入力の長さに上限を設ける、Java・Python・PCRE ならアトミックグループ (?>...) や a++ を使う、といった方法で防げます。

よくある質問

Q. 正規表現の書き方は、どの言語でも同じですか？ A. 基本の記号（. [] * + ? {} ^ $ () |）は共通です。違いが出やすいのは、名前付きグループ（Python は (?P<name>)）、後読みの長さの制限、Unicode プロパティ \p{...}、置換での参照（$1 と \1）、そして grep・sed の BRE で + や {} にバックスラッシュが必要な点です。

Q. \d と [0-9] はどちらを使えばよいですか？ A. 半角数字だけを受け付けたいなら [0-9] が確実です。Python 3 の \d は全角数字「１」にも一致し、grep・sed の標準モードでは \d が「d」という文字に一致しました。

Q. 最短一致（非貪欲）が効かないのはなぜですか？ A. grep -E や sed -E の ERE には最短一致の記法がありません。.+? は「.+ を0回か1回」と解釈され、貪欲のままになります。[^>]+ のような否定の文字クラスで書き換えるか、grep なら -P を使います。

Q. 正規表現の動きを手軽に確かめる方法は？ A. ブラウザの開発者ツールのコンソールで /パターン/.test("文字列") を実行するのが手軽です。本番で使う言語と同じ処理系で確かめると、この記事の比較表にあるような違いにも気づけます。

まとめ

• 最初に覚えるのは . [] \d * + ? {} ^ $ () | の11個
• 処理系で書き方が違う：Python の名前付きグループは (?P<name>)、grep・sed の標準は \d と最短一致が使えない
• 後読みは JavaScript だけ長さ自由、Python と grep -P は固定長、grep -P なら \K で代用できる
• 半角数字だけなら [0-9]。Python の \d は全角数字にも一致する
• 形のチェックは正規表現、中身の正しさ（存在する日付など）は別の処理で
• 全体一致は fullmatch() / matches() / ^...$ を使い分ける
• 最短一致の代わりに否定の文字クラス [^>]+ を使うと、どの処理系でも同じ結果になる

株式会社RJCでは、言語やツールごとの細かな違いを実際に動かして確かめ、その結果をチームで共有しながら開発を進めています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。