import re
 
# 日付パターンから年月日を個別に抽出
pattern = r'(\d{4})-(\d{2})-(\d{2})'
text = "今日は 2026-02-11 です"
 
match = re.search(pattern, text)
print(match.group(0))  # => '2026-02-11' (マッチ全体)
print(match.group(1))  # => '2026'       (グループ1: 年)
print(match.group(2))  # => '02'         (グループ2: 月)
print(match.group(3))  # => '11'         (グループ3: 日)
print(match.groups())  # => ('2026', '02', '11')

import re
 
pattern = r'((A)(B(C)))'
match = re.search(pattern, "ABC")
 
print(match.group(0))  # => 'ABC'
print(match.group(1))  # => 'ABC'
print(match.group(2))  # => 'A'
print(match.group(3))  # => 'BC'
print(match.group(4))  # => 'C'

import re
 
# グループ内で選択 (|)
pattern = r'(cat|dog|bird)s?'
text = "I have 2 cats and 3 dogs"
 
matches = re.findall(pattern, text)
print(matches)  # => ['cat', 'dog']
# 注意: findall はグループがあるとグループの中身を返す
 
# グループの中身ではなく全体マッチが必要な場合
matches_full = re.finditer(pattern, text)
for m in matches_full:
    print(f"  全体: {m.group(0)}, グループ1: {m.group(1)}")
# => 全体: cats, グループ1: cat
# => 全体: dogs, グループ1: dog

import re
 
# HTML属性の抽出: class="value" または class='value'
html = '<div class="main container" id="app" data-role=\'admin\'>'
pattern = r'(\w+)=((["\'])(.*?)\3)'
 
for m in re.finditer(pattern, html):
    print(f"  属性名: {m.group(1)}, 値: {m.group(4)}, 引用符: {m.group(3)}")
# => 属性名: class, 値: main container, 引用符: "
# => 属性名: id, 値: app, 引用符: "
# => 属性名: data-role, 値: admin, 引用符: '

import re
 
# ログ解析: タイムスタンプ、レベル、メッセージを一括抽出
log_pattern = re.compile(
    r'\[(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\]\s+'  # グループ1: タイムスタンプ
    r'\[(DEBUG|INFO|WARN|ERROR|FATAL)\]\s+'              # グループ2: ログレベル
    r'\[(\w+)\]\s+'                                      # グループ3: モジュール名
    r'(.*)'                                              # グループ4: メッセージ
)
 
log_lines = [
    "[2026-02-11 10:30:45] [ERROR] [AuthModule] Login failed for user admin",
    "[2026-02-11 10:31:00] [INFO] [Database] Connection pool initialized (size=10)",
    "[2026-02-11 10:31:15] [WARN] [Cache] Cache miss rate exceeds 50%",
]
 
for line in log_lines:
    m = log_pattern.search(line)
    if m:
        ts, level, module, msg = m.groups()
        print(f"  {ts} | {level:5s} | {module:12s} | {msg}")

// JavaScript でのキャプチャグループ
const text = "2026-02-11 Error at 10:30:45";
const pattern = /(\d{4})-(\d{2})-(\d{2})/;
 
const match = text.match(pattern);
console.log(match[0]);  // '2026-02-11' (全体)
console.log(match[1]);  // '2026' (グループ1)
console.log(match[2]);  // '02' (グループ2)
console.log(match[3]);  // '11' (グループ3)
 
// matchAll を使った全グループの取得 (ES2020)
const logPattern = /\[(\w+)\]\s+(\w+)/g;
const logText = "[ERROR] AuthFailed [WARN] HighLoad";
 
for (const m of logText.matchAll(logPattern)) {
    console.log(`Level: ${m[1]}, Message: ${m[2]}`);
}
// => Level: ERROR, Message: AuthFailed
// => Level: WARN, Message: HighLoad

package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    text := "2026-02-11 Error at 10:30:45"
    re := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
 
    // FindStringSubmatch: サブマッチ付きで返す
    match := re.FindStringSubmatch(text)
    if match != nil {
        fmt.Printf("全体: %s, 年: %s, 月: %s, 日: %s\n",
            match[0], match[1], match[2], match[3])
    }
 
    // FindAllStringSubmatch: 全マッチのサブマッチ
    allMatches := re.FindAllStringSubmatch(text, -1)
    for _, m := range allMatches {
        fmt.Printf("  マッチ: %v\n", m)
    }
}

use regex::Regex;
 
fn main() {
    let text = "2026-02-11 Error at 10:30:45";
    let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
 
    // captures: キャプチャグループ付きマッチ
    if let Some(caps) = re.captures(text) {
        println!("全体: {}", &caps[0]);
        println!("年: {}", &caps[1]);
        println!("月: {}", &caps[2]);
        println!("日: {}", &caps[3]);
    }
 
    // captures_iter: 全マッチのキャプチャ
    for caps in re.captures_iter(text) {
        println!("  マッチ: {}", &caps[0]);
    }
}

import re
 
# キャプチャグループ -- グループ番号が割り当てられる
pattern_capture = r'(https?)://([\w.]+)'
match = re.search(pattern_capture, "https://example.com")
print(match.group(1))  # => 'https'
print(match.group(2))  # => 'example.com'
 
# 非キャプチャグループ -- グループ番号が割り当てられない
pattern_noncapture = r'(?:https?)://([\w.]+)'
match = re.search(pattern_noncapture, "https://example.com")
print(match.group(1))  # => 'example.com' (番号がずれない)
# match.group(2) → エラー (グループ2は存在しない)

import re
 
# NG: 不要なキャプチャ -- グループ番号が無駄に増える
pattern_bad = r'(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar) (\d{4})'
# グループ: 1=曜日, 2=日, 3=月, 4=年
# 曜日(グループ1)を使わない場合、番号が無駄にずれる
 
# OK: 不要な部分は非キャプチャ
pattern_good = r'(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar) (\d{4})'
# グループ: 1=日, 2=月, 3=年 -- 必要なものだけ番号が付く

import re
import timeit
 
text = "The quick brown fox jumps over the lazy dog" * 1000
 
# キャプチャグループ版
pattern_capture = re.compile(r'(\w+)\s+(\w+)\s+(\w+)\s+(\w+)')
 
# 非キャプチャグループ版
pattern_noncapture = re.compile(r'(?:\w+)\s+(?:\w+)\s+(?:\w+)\s+(?:\w+)')
 
# 測定
t_capture = timeit.timeit(
    lambda: pattern_capture.findall(text), number=1000
)
t_noncapture = timeit.timeit(
    lambda: pattern_noncapture.findall(text), number=1000
)
 
print(f"キャプチャ版:    {t_capture:.4f}s")
print(f"非キャプチャ版:  {t_noncapture:.4f}s")
print(f"速度差: {(t_capture - t_noncapture) / t_capture * 100:.1f}%")
# 非キャプチャ版は通常 5-15% 高速

import re
 
# 日時パターン: 非キャプチャで構造化しつつ、必要な部分だけキャプチャ
datetime_pattern = re.compile(r'''
    (?P<date>                          # 日付全体(名前付きキャプチャ)
        (?P<year>\d{4})                # 年(名前付きキャプチャ)
        [-/]                           # セパレータ(グループ化不要)
        (?P<month>\d{2})               # 月(名前付きキャプチャ)
        [-/]                           # セパレータ
        (?P<day>\d{2})                 # 日(名前付きキャプチャ)
    )
    (?:\s+|T)                          # 日付と時刻の区切り(非キャプチャ)
    (?P<time>                          # 時刻全体(名前付きキャプチャ)
        (?P<hour>\d{2})                # 時(名前付きキャプチャ)
        :(?P<minute>\d{2})             # 分(名前付きキャプチャ)
        (?::(?P<second>\d{2}))?        # 秒(任意、名前付きキャプチャ)
    )
    (?:\s*(?P<tz>[A-Z]{3,4}|[+-]\d{2}:?\d{2}))?  # タイムゾーン(任意)
''', re.VERBOSE)
 
test_strings = [
    "2026-02-11 10:30:45 JST",
    "2026/02/11T10:30",
    "2026-02-11 10:30:45+09:00",
]
 
for s in test_strings:
    m = datetime_pattern.search(s)
    if m:
        print(f"  入力: {s}")
        print(f"    日付: {m.group('date')}, 時刻: {m.group('time')}")
        print(f"    年: {m.group('year')}, 月: {m.group('month')}, 日: {m.group('day')}")
        tz = m.group('tz')
        if tz:
            print(f"    TZ: {tz}")

import re
 
# 名前付きグループで日付をパース
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
text = "Date: 2026-02-11"
 
match = re.search(pattern, text)
 
# 名前でアクセス
print(match.group('year'))   # => '2026'
print(match.group('month'))  # => '02'
print(match.group('day'))    # => '11'
 
# groupdict() で辞書として取得
print(match.groupdict())
# => {'year': '2026', 'month': '02', 'day': '11'}
 
# 番号でもアクセス可能
print(match.group(1))  # => '2026'

// JavaScript の名前付きグループ
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const text = "Date: 2026-02-11";
 
const match = text.match(pattern);
console.log(match.groups);
// => { year: '2026', month: '02', day: '11' }
console.log(match.groups.year);   // => '2026'
 
// 分割代入との組み合わせ
const { year, month, day } = match.groups;
console.log(`${year}年${month}月${day}日`);
// => '2026年02月11日'
 
// replace での名前付きグループ参照
const result = "2026-02-11".replace(
    /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/,
    '$<day>/$<month>/$<year>'
);
console.log(result);  // => '11/02/2026'
 
// String.prototype.replaceAll + 名前付きグループ (ES2021)
const multiDates = "Start: 2026-02-11, End: 2026-03-15";
const formatted = multiDates.replaceAll(
    /(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g,
    '$<d>/$<m>/$<y>'
);
console.log(formatted);
// => 'Start: 11/02/2026, End: 15/03/2026'

package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    // Go での名前付きグループ: (?P<name>...)
    re := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
    text := "Date: 2026-02-11"
 
    match := re.FindStringSubmatch(text)
    if match == nil {
        return
    }
 
    // SubexpNames() で名前を取得
    result := make(map[string]string)
    for i, name := range re.SubexpNames() {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }
 
    fmt.Printf("年: %s, 月: %s, 日: %s\n",
        result["year"], result["month"], result["day"])
    // => 年: 2026, 月: 02, 日: 11
 
    // ヘルパー関数として整理
    fmt.Println(extractNamedGroups(re, text))
}
 
// 汎用ヘルパー関数
func extractNamedGroups(re *regexp.Regexp, text string) map[string]string {
    match := re.FindStringSubmatch(text)
    if match == nil {
        return nil
    }
    result := make(map[string]string)
    for i, name := range re.SubexpNames() {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }
    return result
}

use regex::Regex;
use std::collections::HashMap;
 
fn main() {
    let re = Regex::new(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})").unwrap();
    let text = "Date: 2026-02-11";
 
    if let Some(caps) = re.captures(text) {
        // 名前でアクセス
        println!("年: {}", &caps["year"]);    // => 年: 2026
        println!("月: {}", &caps["month"]);   // => 月: 02
        println!("日: {}", &caps["day"]);     // => 日: 11
 
        // name() メソッドで Option<Match> を取得
        if let Some(year) = caps.name("year") {
            println!("年の位置: {}-{}", year.start(), year.end());
        }
    }
 
    // 全マッチから名前付きグループを HashMap に変換
    let results: Vec<HashMap<&str, &str>> = re.captures_iter(text)
        .map(|caps| {
            re.capture_names()
                .flatten()
                .filter_map(|name| {
                    caps.name(name).map(|m| (name, m.as_str()))
                })
                .collect()
        })
        .collect();
 
    println!("{:?}", results);
}

import re
 
# \1 でグループ1のマッチを参照
# 同じ文字列の繰り返しを検出
 
# HTML開始タグと終了タグの対応
pattern = r'<(\w+)>.*?</\1>'
text = '<div>hello</div> <span>world</span>'
 
matches = re.findall(pattern, text)
print(matches)  # => ['div', 'span']
 
# 重複単語の検出
pattern = r'\b(\w+)\s+\1\b'
text = "the the quick brown fox fox"
print(re.findall(pattern, text))  # => ['the', 'fox']

import re
 
# (?P=name) で名前付きグループを後方参照
pattern = r'(?P<quote>["\']).*?(?P=quote)'
text = """He said "hello" and 'world'"""
 
matches = re.findall(pattern, text)
print(matches)  # => ['"', "'"]
 
# finditer で全体を取得
for m in re.finditer(pattern, text):
    print(m.group())
# => "hello"
# => 'world'

import re
 
# \1 または \g<1> で置換時にグループを参照
text = "2026-02-11"
 
# 日付形式の変換: YYYY-MM-DD → DD/MM/YYYY
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\3/\2/\1', text)
print(result)  # => '11/02/2026'
 
# 名前付きグループで置換
result = re.sub(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
    r'\g<day>/\g<month>/\g<year>',
    text
)
print(result)  # => '11/02/2026'
 
# 関数を使った高度な置換
def format_date(match):
    y, m, d = match.group('year'), match.group('month'), match.group('day')
    return f"{y}年{m}月{d}日"
 
result = re.sub(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
    format_date,
    text
)
print(result)  # => '2026年02月11日'

import re
 
# 1. 回文検出（3〜5文字の回文）
palindrome_3 = r'\b(\w)(\w)\2\1\b'  # 4文字の回文
text = "abba deed noon hello"
for m in re.finditer(palindrome_3, text):
    print(f"  回文: {m.group()}")
# => 回文: abba
# => 回文: deed
# => 回文: noon
 
# 2. XML/HTML の対応タグ検出（ネストなし）
xml_tag = r'<(?P<tag>\w+)(?:\s[^>]*)?>(?P<content>.*?)</(?P=tag)>'
html = '<p class="intro">Hello</p> <div>World</div>'
for m in re.finditer(xml_tag, html):
    print(f"  タグ: {m.group('tag')}, 内容: {m.group('content')}")
 
# 3. CSV の引用符付きフィールド
csv_field = r'(?P<quote>["\'])(?P<value>(?:(?!(?P=quote)).)*|(?:(?P=quote){2})*)(?P=quote)'
csv_line = '"hello","world","it""s a test"'
for m in re.finditer(csv_field, csv_line):
    print(f"  値: {m.group('value')}")
 
# 4. 同じ文字の繰り返し検出（パスワードチェック等）
repeated_char = r'(.)\1{2,}'  # 同じ文字が3回以上連続
passwords = ["abc", "aabbc", "aaabbb", "password111"]
for pwd in passwords:
    m = re.search(repeated_char, pwd)
    if m:
        print(f"  NG: {pwd} ('{m.group(1)}' が {len(m.group())} 回連続)")

// JavaScript での後方参照
 
// 1. パターン内後方参照
const html = '<div>hello</div> <span>world</span>';
const tagPattern = /<(\w+)>.*?<\/\1>/g;
let m;
while ((m = tagPattern.exec(html)) !== null) {
    console.log(`  マッチ: ${m[0]}, タグ: ${m[1]}`);
}
 
// 2. 名前付き後方参照 (ES2018)
const quotePattern = /(?<q>["']).*?\k<q>/g;
const text = `He said "hello" and 'world'`;
for (const match of text.matchAll(quotePattern)) {
    console.log(`  マッチ: ${match[0]}`);
}
 
// 3. 置換での後方参照
const date = "2026-02-11";
console.log(date.replace(
    /(\d{4})-(\d{2})-(\d{2})/,
    '$3/$2/$1'
));  // => '11/02/2026'
 
// 名前付きグループでの置換
console.log(date.replace(
    /(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
    '$<d>/$<m>/$<y>'
));  // => '11/02/2026'

import re
 
# 「の後に特定パターンが続く」位置をマッチ
 
# 1. 金額の前の通貨記号を検出（数字は消費しない）
text = "$100 €200 ¥300"
pattern = r'$€¥'
for m in re.finditer(pattern, text):
    print(f"  通貨記号: {m.group()} at {m.start()}")
 
# 2. パスワード強度チェック: 複数条件の同時検査
# 先読みを使うと、パターン全体を消費せずに複数条件をチェックできる
password_pattern = re.compile(r'''
    ^
    (?=.*[A-Z])        # 大文字を含む
    (?=.*[a-z])        # 小文字を含む
    (?=.*\d)           # 数字を含む
    (?=.*[!@#$%^&*])   # 記号を含む
    .{8,}              # 8文字以上
    $
''', re.VERBOSE)
 
passwords = ["MyP@ss1", "MyP@ssw0rd", "password", "PASSWORD1!", "Ab1!abcd"]
for pwd in passwords:
    result = "OK" if password_pattern.match(pwd) else "NG"
    print(f"  {result}: {pwd}")
 
# 3. 3桁ごとのカンマ区切り
def add_commas(number_str):
    """先読みを使って3桁ごとにカンマを挿入"""
    return re.sub(r'(?<=\d)(?=(\d{3})+(?!\d))', ',', number_str)
 
print(add_commas("1234567890"))   # => '1,234,567,890'
print(add_commas("12345"))        # => '12,345'
print(add_commas("123"))          # => '123'

import re
 
# 「の後に特定パターンが続かない」位置をマッチ
 
# 1. 拡張子が .exe でないファイル名
filenames = ["report.pdf", "virus.exe", "photo.jpg", "setup.exe", "data.csv"]
pattern = r'\w+\.(?!exe\b)\w+'
for f in filenames:
    m = re.fullmatch(pattern, f)
    if m:
        print(f"  安全: {f}")
# => 安全: report.pdf
# => 安全: photo.jpg
# => 安全: data.csv
 
# 2. 予約語でない識別子
reserved = "if|else|for|while|return|class|def"
identifier_pattern = re.compile(rf'\b(?!(?:{reserved})\b)[a-zA-Z_]\w*\b')
code = "if x > 0: return calculate(x) else: count = 0"
identifiers = identifier_pattern.findall(code)
print(f"  識別子: {identifiers}")
# => 識別子: ['x', 'calculate', 'x', 'count']
 
# 3. 特定のドメインを除外したURL抽出
urls = [
    "https://example.com/page",
    "https://spam.example.net/malware",
    "https://trusted.org/resource",
    "https://ads.tracker.com/pixel",
]
blocked_domains = r'spam\.example\.net|ads\.tracker\.com'
safe_url_pattern = re.compile(rf'https?://(?!{blocked_domains})[^\s]+')
for url in urls:
    m = safe_url_pattern.match(url)
    if m:
        print(f"  許可: {url}")

import re
 
# 「の前に特定パターンがある」位置をマッチ
 
# 1. 通貨記号の後の金額を抽出
text = "$100 €200 ¥300 free"
dollar_amounts = re.findall(r'(?<=\$)\d+', text)
print(f"  ドル金額: {dollar_amounts}")  # => ['100']
 
# 2. @メンション の抽出
tweet = "Hello @alice and @bob, check out @charlie's work"
mentions = re.findall(r'(?<=@)\w+', tweet)
print(f"  メンション: {mentions}")  # => ['alice', 'bob', 'charlie']
 
# 3. JSON 値の抽出（キー名の後の値）
json_text = '"name": "Alice", "age": 30, "city": "Tokyo"'
name_value = re.search(r'(?<="name":\s*")[^"]+', json_text)
if name_value:
    print(f"  name の値: {name_value.group()}")  # => Alice

import re
 
# 「の前に特定パターンがない」位置をマッチ
 
# 1. エスケープされていない引用符を検出
text = r'He said \"hello\" and "world"'
# \" は除外して、" だけをマッチ
unescaped_quotes = re.findall(r'(?<!\\)"', text)
print(f"  非エスケープ引用符の数: {len(unescaped_quotes)}")
 
# 2. http:// ではない（つまりプロトコル付きでない）URL パス
paths = ["/api/users", "http://example.com/api", "/api/items", "https://x.com"]
path_only = re.compile(r'(?<!https?)(?<!:)/\w[\w/]*')
 
# 3. 行頭のインデントではないスペースを検出
code = "def foo():\n    return bar  + baz"
# 連続する2つ以上のスペース（ただし行頭を除く）
extra_spaces = re.findall(r'(?<=\S)\s{2,}(?=\S)', code)
print(f"  余分なスペース箇所: {len(extra_spaces)}")

import re
 
# 先読みと後読みの組み合わせで、囲まれた部分だけを取得
 
# 1. HTML タグの中身だけ抽出（タグ自体は含めない）
html = "<b>bold</b> and <i>italic</i>"
content = re.findall(r'(?<=<\w+>).*?(?=</\w+>)', html)
print(f"  タグの中身: {content}")  # => ['bold', 'italic']
 
# 2. 括弧の中身だけ抽出
text = "関数 foo(x, y) は bar(z) を呼ぶ"
args = re.findall(r'(?<=\()[^)]+(?=\))', text)
print(f"  引数: {args}")  # => ['x, y', 'z']
 
# 3. キャメルケースの単語境界に空白を挿入
camel = "getUserNameFromDatabase"
result = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', camel)
print(f"  変換: {result}")  # => 'get User Name From Database'
 
# snake_case に変換
snake = re.sub(r'(?<=[a-z])(?=[A-Z])', '_', camel).lower()
print(f"  snake_case: {snake}")  # => 'get_user_name_from_database'

// JavaScript (ES2018) は可変長の後読みもサポート
 
// 肯定後読み (可変長)
const text1 = "USD100 EUR200 JPY3000";
const amounts = text1.match(/(?<=USD|EUR|JPY)\d+/g);
console.log(amounts);  // => ['100', '200', '3000']
// 注意: USD(3文字) と JPY(3文字) は同じ長さだが、
// JavaScript は可変長後読みも許可
 
// 否定後読み + 肯定先読み の組み合わせ
const code = "let x = 10; const y = 20; var z = 30;";
// const/let で宣言された変数名のみ取得 (var は除外)
const modernVars = code.match(/(?<=(?:const|let)\s+)\w+/g);
console.log(modernVars);  // => ['x', 'y']

import re
import time
 
# 危険なパターン: (a+)+ は壊滅的バックトラッキングを引き起こす
dangerous_pattern = re.compile(r'(a+)+b')
 
# 短い入力: 高速
text_short = "aaaaab"
start = time.time()
dangerous_pattern.search(text_short)
print(f"  短い入力: {time.time() - start:.4f}s")
 
# マッチしない長い入力: 指数時間
# 注意: 下の行は実行すると非常に遅い（n=25 でも数秒かかる）
# text_long = "a" * 25 + "c"
# dangerous_pattern.search(text_long)  # 危険！数秒〜数分かかる
 
# 安全な代替パターン
safe_pattern = re.compile(r'a+b')  # グループのネストを排除
# または非キャプチャ + 独占的量指定子（サポートされている言語で）

// Java での独占的量指定子による対策
import java.util.regex.*;
 
public class AtomicExample {
    public static void main(String[] args) {
        // 危険: 壊滅的バックトラッキング
        // Pattern dangerous = Pattern.compile("(a+)+b");
 
        // 安全: 独占的量指定子
        Pattern safe = Pattern.compile("a++b");
 
        String input = "a".repeat(30) + "c";
        long start = System.nanoTime();
        safe.matcher(input).find();
        long elapsed = System.nanoTime() - start;
        System.out.printf("  所要時間: %.3f ms%n", elapsed / 1e6);
        // => 即座に完了
    }
}

import re
 
# 1. 開き括弧があれば閉じ括弧を要求
pattern = r'(\()?hello(?(1)\))'
# (?(1)\)) = グループ1がマッチしていれば \) を要求
 
print(re.search(pattern, "hello").group())    # => 'hello'
print(re.search(pattern, "(hello)").group())  # => '(hello)'
print(re.search(pattern, "(hello").group())   # => 'hello' (括弧なし版にマッチ)
 
# 2. 引用符の対応チェック
# 開き引用符があれば同じ閉じ引用符を要求
quote_pattern = r'(?P<q>["\'])?(?P<content>\w+)(?(q)(?P=q))'
test_strings = ['"hello"', "'world'", 'plain', '"mismatch\'']
for s in test_strings:
    m = re.search(quote_pattern, s)
    if m:
        print(f"  {s} → content: {m.group('content')}")
 
# 3. オプショナルなプレフィックスに応じた形式変更
# +81 があれば国際形式、なければ国内形式
phone_pattern = r'(\+81)?-?(?(1)\d{1,4}-\d{1,4}-\d{4}|0\d{1,4}-\d{1,4}-\d{4})'
phones = ["+81-90-1234-5678", "090-1234-5678", "+81-3-1234-5678", "03-1234-5678"]
for p in phones:
    m = re.match(phone_pattern, p)
    if m:
        print(f"  マッチ: {m.group()}")

import re
 
# 名前付きグループを使った条件分岐
# メールアドレスの表示名: "Name <email>" または単独 "email"
pattern = r'(?:(?P<display_name>[^<]+)\s+)?<(?P<email>[^>]+)>(?(display_name)|\s*(?P<email_only>[^\s]+))?'
 
# より実用的な例: タグ形式またはプレーン形式
# <tag attr="val">content</tag> または プレーンテキスト
tag_or_plain = r'(?P<open><(?P<tagname>\w+)[^>]*>)?(?(open)(?P<content>.*?)</(?P=tagname)>|(?P<plain>.+))'
tests = ["<b>bold text</b>", "plain text", "<a href='url'>link</a>"]
for t in tests:
    m = re.match(tag_or_plain, t)
    if m:
        if m.group('open'):
            print(f"  タグ: {m.group('tagname')}, 内容: {m.group('content')}")
        else:
            print(f"  プレーン: {m.group('plain')}")

import re
 
# NG: 全てをキャプチャグループにする
pattern_bad = r'(https?)://(www\.)?(\w+)\.(\w+)/(\w+)/(\w+)'
# グループが6個 → 番号の管理が困難
 
# OK: 必要な部分のみキャプチャ + 名前付き
pattern_good = r'(?:https?)://(?:www\.)?(?P<domain>\w+\.\w+)/(?P<path>\w+/\w+)'
 
text = "https://www.example.com/api/users"
match = re.search(pattern_good, text)
if match:
    print(match.group('domain'))  # => 'example.com'
    print(match.group('path'))    # => 'api/users'

import re
 
# NG: グループ番号のハードコード -- パターン変更時にバグを生む
pattern = r'(\w+)\s+(\d+)\s+(\w+)'
text = "item 42 completed"
match = re.search(pattern, text)
name = match.group(1)    # パターン変更でずれる
count = match.group(2)   # パターン変更でずれる
 
# OK: 名前付きグループ -- パターン変更に強い
pattern = r'(?P<name>\w+)\s+(?P<count>\d+)\s+(?P<status>\w+)'
match = re.search(pattern, text)
name = match.group('name')      # 名前で参照 → ずれない
count = match.group('count')    # 名前で参照 → ずれない

import re
 
# NG: 先読みだけでパスワードを検証（理解困難）
password_bad = r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[!@#$%^&*])(?=.{8,})(?!.*(.)\1{2,})(?!.*(?:123|abc|password)).*$'
# → 一行に詰め込みすぎて保守不能
 
# OK: VERBOSE フラグ + コメントで構造化
password_good = re.compile(r'''
    ^
    (?=.*[A-Z])            # 条件1: 大文字を含む
    (?=.*[a-z])            # 条件2: 小文字を含む
    (?=.*\d)               # 条件3: 数字を含む
    (?=.*[!@#$%^&*])       # 条件4: 記号を含む
    (?!.*(.)\1{2,})        # 条件5: 同じ文字の3連続を禁止
    (?!.*(?:123|abc|pwd))  # 条件6: 弱いパターンを禁止
    .{8,}                  # 本体: 8文字以上
    $
''', re.VERBOSE)
 
# さらに良い方法: 個別チェック関数
def validate_password(pwd: str) -> list[str]:
    """パスワード検証: 各条件を個別にチェックし、失敗理由を返す"""
    errors = []
    if len(pwd) < 8:
        errors.append("8文字以上必要")
    if not re.search(r'[A-Z]', pwd):
        errors.append("大文字を含めてください")
    if not re.search(r'[a-z]', pwd):
        errors.append("小文字を含めてください")
    if not re.search(r'\d', pwd):
        errors.append("数字を含めてください")
    if not re.search(r'[!@#$%^&*]', pwd):
        errors.append("記号を含めてください")
    if re.search(r'(.)\1{2,}', pwd):
        errors.append("同じ文字を3回以上連続させないでください")
    return errors

// NG: Go では先読みは使えない
// re := regexp.MustCompile(`\d+(?=円)`)  // パニック!
 
// OK: 代替手法 - キャプチャグループで取得して後処理
package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re := regexp.MustCompile(`(\d+)円`)
    text := "100円 200ドル 300円"
 
    matches := re.FindAllStringSubmatch(text, -1)
    for _, m := range matches {
        fmt.Printf("  金額: %s\n", m[1])
    }
    // => 金額: 100
    // => 金額: 300
}

// NG: Rust の regex クレートでは先読みは使えない
// let re = Regex::new(r"\d+(?=円)").unwrap();  // エラー!
 
// OK1: キャプチャグループで代替
use regex::Regex;
 
fn main() {
    let re = Regex::new(r"(\d+)円").unwrap();
    let text = "100円 200ドル 300円";
 
    for caps in re.captures_iter(text) {
        println!("  金額: {}", &caps[1]);
    }
 
    // OK2: fancy-regex を使う（先読み・後読み対応）
    // use fancy_regex::Regex;
    // let re = Regex::new(r"\d+(?=円)").unwrap();
}

import re
 
# NG: 一行の読みにくいパターン
bad = r'((?:\+81|0)[\d-]{9,13})|(\d{3}-?\d{4})|([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'
 
# OK: VERBOSE + 名前付きグループ + コメント
good = re.compile(r'''
    (?P<phone>                              # 電話番号
        (?:\+81|0)                          #   国番号または先頭の0
        [\d-]{9,13}                         #   数字とハイフン
    )
    |
    (?P<postal>                             # 郵便番号
        \d{3}-?\d{4}                        #   XXX-XXXX形式
    )
    |
    (?P<email>                              # メールアドレス
        [a-zA-Z0-9._%+-]+                   #   ローカルパート
        @                                   #   @
        [a-zA-Z0-9.-]+                      #   ドメイン
        \.[a-zA-Z]{2,}                      #   TLD
    )
''', re.VERBOSE)
 
text = "連絡先: 090-1234-5678, 〒100-0001, info@example.com"
for m in good.finditer(text):
    for name in ['phone', 'postal', 'email']:
        if m.group(name):
            print(f"  {name}: {m.group(name)}")

import re
 
# 1. 先読みは必要な場所だけに限定する
# NG: 無意味な先読み
bad1 = r'(?=\d)\d+'  # 先読みの後に同じパターン → 無意味
 
# OK: 先読みなしで同じ結果
good1 = r'\d+'
 
# 2. 非キャプチャグループでバックトラックを抑制
# NG: ネストしたキャプチャグループ + 量指定子
bad2 = r'((\w+)\s*)+'  # 壊滅的バックトラッキングのリスク
 
# OK: フラットな構造
good2 = r'\w+(?:\s+\w+)*'
 
# 3. 交替(|)の順序を最適化
# 短い文字列が多い場合、短いパターンを先に
# NG: 長いパターンから
bad3 = r'(?:January|February|March|April|May|June|July|August|September|October|November|December)'
 
# OK: 先頭文字でグループ化（エンジンによっては自動最適化される）
good3 = r'(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)'

import re
 
text = "cats and dogs"
# findall + グループ → グループの中身のみ
print(re.findall(r'(cat|dog)s', text))  # => ['cat', 'dog']
 
# 方法1: finditer を使う
for m in re.finditer(r'(cat|dog)s', text):
    print(f"全体: {m.group(0)}, 動物: {m.group(1)}")
 
# 方法2: 非キャプチャグループにする
print(re.findall(r'(?:cat|dog)s', text))  # => ['cats', 'dogs']

import re
 
# 開き括弧があれば閉じ括弧を要求
pattern = r'(\()?hello(?(1)\))'
# (?(1)\)) = グループ1がマッチしていれば \) を要求
 
print(re.search(pattern, "hello").group())    # => 'hello'
print(re.search(pattern, "(hello)").group())  # => '(hello)'
print(re.search(pattern, "(hello").group())   # => 'hello' (括弧なし版にマッチ)

# .NET での例(概念):
# (?<digit>\d+)|(?<digit>[a-f]+)  -- 両方とも "digit" グループ
 
# Python regex モジュールでのブランチリセット:
# (?|(\d+)|([a-f]+))  -- どちらもグループ1

import re
 
# 先読み内のキャプチャグループ
pattern = r'(?=(\d+)円)\d+'
text = "100円 200ドル 300円"
 
for m in re.finditer(pattern, text):
    print(f"  数値: {m.group()}, 先読み内グループ: {m.group(1)}")
# => 数値: 100, 先読み内グループ: 100
# => 数値: 300, 先読み内グループ: 300

// Rust: fancy-regex を使った先読みの例
// Cargo.toml: fancy-regex = "0.13"
use fancy_regex::Regex;
 
fn main() {
    // 肯定先読み: 数値の後に「円」が続くもの
    let re = Regex::new(r"\d+(?=円)").unwrap();
    let text = "100円 200ドル 300円";
 
    for m in re.find_iter(text) {
        if let Ok(m) = m {
            println!("  金額: {}", m.as_str());
        }
    }
}

<div class="container" id="main">
<img src="photo.jpg" alt="写真">
<a href="https://example.com" target="_blank">リンク</a>