🚀 정규표현식, 넌 누구냐?

야, 프로그래밍 하다 보면 텍스트 처리가 진짜 골치 아플 때 많지 않아? 🤔
이메일 형식 체크해야 하는데, 전화번호 추출해야 하는데, URL 찾아야 하는데...
이럴 때마다 if문 수십 개 쓰면서 "이게 맞나?" 싶을 때 있잖아.

바로 그때 필요한 게 정규표현식(Regular Expression)이야!
영어로는 Regex 또는 RegExp라고 부르는데, 이건 텍스트 패턴을 표현하는 특별한 문자열이야.
마치 텍스트를 찾는 마법 주문 같은 거지. ✨

🔧 PHP와 PCRE의 만남

PHP에서 정규표현식을 쓸 때는 PCRE(Perl Compatible Regular Expressions)라는 라이브러리를 사용해.
이름에서 알 수 있듯이 Perl 언어의 정규표현식 문법과 호환되는 방식이야. 🐪

PHP 4.2.0 버전부터 기본으로 탑재되어 있어서 별도 설치 없이 바로 쓸 수 있어.
PCRE는 강력하고 유연해서 거의 모든 텍스트 패턴 매칭 작업을 처리할 수 있지!

🎨 정규표현식 패턴 문법 완전정복

자, 이제 본격적으로 정규표현식 패턴을 어떻게 쓰는지 알아보자!
처음엔 외계어 같지만 익숙해지면 진짜 강력한 도구가 돼. 💪

기본 메타문자들

수량자(Quantifiers) 상세

<?php
// 전화번호 패턴 (지역번호 2-3자리, 국번 3-4자리, 번호 4자리)
$pattern = '/\d{2,3}-\d{3,4}-\d{4}/';

// 비밀번호 검증 (8~16자, 영문+숫자 필수)
$password_pattern = '/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,16}$/';

// 우편번호 (5자리 숫자)
$zipcode_pattern = '/^\d{5}$/';
?>

문자 클래스와 단축 표현

<?php
// 단어 경계 활용 예시
$text = "cat cats category";

// 'cat'이라는 단어만 정확히 찾기
preg_match_all('/\bcat\b/', $text, $matches);
print_r($matches[0]); // Array ( [0] => cat )

// 'cat'으로 시작하는 모든 단어
preg_match_all('/\bcat\w*/', $text, $matches);
print_r($matches[0]); // Array ( [0] => cat [1] => cats [2] => category )
?>

🎯 실전 패턴 예제 모음

이론만 알면 뭐해, 실전에서 못 쓰면! 😅
자주 쓰이는 패턴들을 모아봤어. 복사해서 바로 쓸 수 있게 주석도 달아뒀으니까 참고해!

📧 이메일 검증

<?php
// 기본 이메일 패턴
$pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';

// 더 엄격한 이메일 패턴 (RFC 5322 기반)
$strict_pattern = '/^(?!.*\.\.)(?!.*\.$)[a-zA-Z0-9._%+-]{1,64}@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';

function validateEmail($email) {
    $pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';
    return preg_match($pattern, $email) === 1;
}

// 테스트
echo validateEmail("user@example.com") ? "유효" : "무효"; // 유효
echo validateEmail("invalid@") ? "유효" : "무효"; // 무효
?>

📱 전화번호 검증

<?php
// 한국 휴대폰 번호 (010-1234-5678)
$mobile_pattern = '/^01[0-9]-\d{3,4}-\d{4}$/';

// 하이픈 있거나 없거나 둘 다 허용
$flexible_pattern = '/^01[0-9]-?\d{3,4}-?\d{4}$/';

// 일반 전화번호 (02-123-4567, 031-1234-5678)
$phone_pattern = '/^0\d{1,2}-\d{3,4}-\d{4}$/';

function formatPhone($phone) {
    // 숫자만 추출
    $numbers = preg_replace('/[^0-9]/', '', $phone);
    
    // 휴대폰 번호 형식으로 변환
    if (preg_match('/^(01[0-9])(\d{3,4})(\d{4})$/', $numbers, $matches)) {
        return $matches[1] . '-' . $matches[2] . '-' . $matches[3];
    }
    
    return $phone;
}

echo formatPhone("01012345678"); // 010-1234-5678
?>

🔐 비밀번호 강도 검증

<?php
// 최소 8자, 영문 대소문자, 숫자, 특수문자 각 1개 이상
$strong_password = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/';

// 최소 8자, 영문+숫자 조합
$medium_password = '/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/';

function checkPasswordStrength($password) {
    $patterns = [
        'weak' => '/^.{6,}$/', // 6자 이상
        'medium' => '/^(?=.*[A-Za-z])(?=.*\d).{8,}$/', // 8자 이상, 영문+숫자
        'strong' => '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&]).{8,}$/' // 강력
    ];
    
    if (preg_match($patterns['strong'], $password)) {
        return '강력';
    } elseif (preg_match($patterns['medium'], $password)) {
        return '보통';
    } elseif (preg_match($patterns['weak'], $password)) {
        return '약함';
    }
    return '매우 약함';
}

echo checkPasswordStrength("Pass123!"); // 강력
echo checkPasswordStrength("password123"); // 보통
?>

🌐 URL 검증 및 추출

<?php
// 기본 URL 패턴
$url_pattern = '/^https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?$/';

// 텍스트에서 URL 추출
$text = "방문하세요: https://www.example.com 그리고 http://test.co.kr/page";
preg_match_all('/https?:\/\/[^\s]+/', $text, $urls);
print_r($urls[0]);
// Array ( [0] => https://www.example.com [1] => http://test.co.kr/page )

// URL에서 도메인만 추출
function extractDomain($url) {
    if (preg_match('/^https?:\/\/([^\/]+)/', $url, $matches)) {
        return $matches[1];
    }
    return null;
}

echo extractDomain("https://www.example.com/page"); // www.example.com
?>

💳 신용카드 번호 검증

<?php
// 신용카드 번호 (4자리-4자리-4자리-4자리)
$card_pattern = '/^\d{4}-\d{4}-\d{4}-\d{4}$/';

// 하이픈 없이도 허용
$card_flexible = '/^\d{4}-?\d{4}-?\d{4}-?\d{4}$/';

function maskCardNumber($card) {
    // 마지막 4자리만 보이게
    return preg_replace('/^(\d{4})-?(\d{4})-?(\d{4})-?(\d{4})$/', '****-****-****-$4', $card);
}

echo maskCardNumber("1234-5678-9012-3456"); // ****-****-****-3456
echo maskCardNumber("1234567890123456"); // ****-****-****-3456
?>

📅 날짜 형식 검증

<?php
// YYYY-MM-DD 형식
$date_pattern = '/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/';

// YYYY.MM.DD 또는 YYYY/MM/DD
$date_flexible = '/^\d{4}[.\/-](0[1-9]|1[0-2])[.\/-](0[1-9]|[12]\d|3[01])$/';

function convertDateFormat($date) {
    // 다양한 형식을 YYYY-MM-DD로 통일
    if (preg_match('/^(\d{4})[.\/-](\d{1,2})[.\/-](\d{1,2})$/', $date, $matches)) {
        return sprintf('%04d-%02d-%02d', $matches[1], $matches[2], $matches[3]);
    }
    return $date;
}

echo convertDateFormat("2024.3.5"); // 2024-03-05
echo convertDateFormat("2024/12/25"); // 2024-12-25
?>

🏠 주소 및 우편번호

<?php
// 한국 우편번호 (5자리)
$zipcode_pattern = '/^\d{5}$/';

// 구 우편번호 (123-456) 형식도 허용
$zipcode_old = '/^\d{3}-?\d{3}$/';

// 주민등록번호 (앞자리만, 뒷자리 마스킹)
$jumin_pattern = '/^(\d{6})-?([1-4]\d{6})$/';

function maskJumin($jumin) {
    return preg_replace('/^(\d{6})-?(\d{7})$/', '$1-*******', $jumin);
}

echo maskJumin("900101-1234567"); // 900101-*******
?>

⚙️ 정규표현식 플래그(Modifiers)

패턴 뒤에 붙이는 플래그로 매칭 동작을 조절할 수 있어.
PHP PCRE에서 자주 쓰는 플래그들을 알아보자! 🎚️

플래그 사용 예제

<?php
// i 플래그: 대소문자 무시
$text = "Hello World";
echo preg_match('/hello/i', $text) ? "매칭" : "불일치"; // 매칭

// m 플래그: 멀티라인 모드
$text = "첫 번째 줄\n두 번째 줄\n세 번째 줄";
preg_match_all('/^.+$/m', $text, $matches);
print_r($matches[0]);
// Array ( [0] => 첫 번째 줄 [1] => 두 번째 줄 [2] => 세 번째 줄 )

// s 플래그: 점이 줄바꿈도 매칭
$text = "첫 줄\n둘째 줄";
echo preg_match('/첫 줄.둘째 줄/s', $text) ? "매칭" : "불일치"; // 매칭

// u 플래그: UTF-8 처리 (한글 사용 시 필수!)
$text = "안녕하세요";
preg_match_all('/./u', $text, $matches);
echo count($matches[0]); // 5 (u 없으면 바이트 단위로 계산됨)

// x 플래그: 가독성 좋은 패턴 작성
$pattern = '/
    ^                   # 문자열 시작
    (?P<year>\d{4})     # 년도 4자리
    -                   # 하이픈
    (?P<month>\d{2})    # 월 2자리
    -                   # 하이픈
    (?P<day>\d{2})      # 일 2자리
    $                   # 문자열 끝
/x';

preg_match($pattern, "2024-03-15", $matches);
print_r($matches);

// U 플래그: non-greedy 기본값
$html = "<div>첫 번째</div><div>두 번째</div>";
preg_match_all('/<div>.*<\/div>/U', $html, $matches);
print_r($matches[0]);
// Array ( [0] => <div>첫 번째</div> [1] => <div>두 번째</div> )
?>

🎓 실전 프로젝트: 텍스트 처리 유틸리티 클래스

지금까지 배운 내용을 종합해서 실무에서 바로 쓸 수 있는
텍스트 처리 유틸리티 클래스를 만들어보자! 🛠️

이런 클래스 하나 만들어두면 프로젝트에서 계속 재사용할 수 있어서 정말 편해.
재능넷 같은 플랫폼에서 프로젝트 진행할 때도 유용하게 쓸 수 있을 거야!

<?php
/**
 * 텍스트 처리 유틸리티 클래스
 * 정규표현식을 활용한 다양한 텍스트 검증 및 처리 기능 제공
 */
class TextValidator {
    
    /**
     * 이메일 검증
     */
    public static function isValidEmail($email) {
        $pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';
        return preg_match($pattern, $email) === 1;
    }
    
    /**
     * 한국 휴대폰 번호 검증
     */
    public static function isValidPhone($phone) {
        $pattern = '/^01[0-9]-?\d{3,4}-?\d{4}$/';
        return preg_match($pattern, $phone) === 1;
    }
    
    /**
     * 전화번호 포맷팅
     */
    public static function formatPhone($phone) {
        $numbers = preg_replace('/[^0-9]/', '', $phone);
        
        if (preg_match('/^(01[0-9])(\d{3,4})(\d{4})$/', $numbers, $matches)) {
            return $matches[1] . '-' . $matches[2] . '-' . $matches[3];
        }
        
        if (preg_match('/^(0\d{1,2})(\d{3,4})(\d{4})$/', $numbers, $matches)) {
            return $matches[1] . '-' . $matches[2] . '-' . $matches[3];
        }
        
        return $phone;
    }
    
    /**
     * URL 검증
     */
    public static function isValidUrl($url) {
        $pattern = '/^https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?$/';
        return preg_match($pattern, $url) === 1;
    }
    
    /**
     * 텍스트에서 URL 추출
     */
    public static function extractUrls($text) {
        $pattern = '/https?:\/\/[^\s]+/';
        preg_match_all($pattern, $text, $matches);
        return $matches[0];
    }
    
    /**
     * 비밀번호 강도 체크
     */
    public static function checkPasswordStrength($password) {
        $patterns = [
            'length' => strlen($password) >= 8,
            'lowercase' => preg_match('/[a-z]/', $password),
            'uppercase' => preg_match('/[A-Z]/', $password),
            'number' => preg_match('/\d/', $password),
            'special' => preg_match('/[@$!%*?&#]/', $password)
        ];
        
        $score = array_sum($patterns);
        
        if ($score === 5) return '매우 강력';
        if ($score >= 4) return '강력';
        if ($score >= 3) return '보통';
        if ($score >= 2) return '약함';
        return '매우 약함';
    }
    
    /**
     * HTML 태그 제거 (XSS 방지)
     */
    public static function stripTags($text, $allowedTags = []) {
        if (empty($allowedTags)) {
            return preg_replace('/<[^>]+>/', '', $text);
        }
        
        $allowed = implode('|', array_map('preg_quote', $allowedTags));
        $pattern = '/<(?!\/?(' . $allowed . ')\b)[^>]+>/';
        return preg_replace($pattern, '', $text);
    }
    
    /**
     * 이메일 마스킹
     */
    public static function maskEmail($email) {
        return preg_replace('/^(.{2})[^@]+(@.+)$/', '$1***$2', $email);
    }
    
    /**
     * 전화번호 마스킹
     */
    public static function maskPhone($phone) {
        return preg_replace('/^(\d{3})-?(\d{3,4})-?(\d{4})$/', '$1-****-$3', $phone);
    }
    
    /**
     * 신용카드 번호 마스킹
     */
    public static function maskCardNumber($card) {
        return preg_replace('/^(\d{4})-?(\d{4})-?(\d{4})-?(\d{4})$/', '****-****-****-$4', $card);
    }
    
    /**
     * 텍스트에서 이메일 추출
     */
    public static function extractEmails($text) {
        $pattern = '/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/';
        preg_match_all($pattern, $text, $matches);
        return $matches[0];
    }
    
    /**
     * 한글만 추출
     */
    public static function extractKorean($text) {
        preg_match_all('/[가-힣]+/u', $text, $matches);
        return implode('', $matches[0]);
    }
    
    /**
     * 숫자만 추출
     */
    public static function extractNumbers($text) {
        return preg_replace('/[^0-9]/', '', $text);
    }
    
    /**
     * 여러 공백을 하나로
     */
    public static function normalizeSpaces($text) {
        return preg_replace('/\s+/', ' ', trim($text));
    }
    
    /**
     * 검색어 하이라이트
     */
    public static function highlight($text, $keyword, $tag = 'mark') {
        $safe_keyword = preg_quote($keyword, '/');
        return preg_replace("/($safe_keyword)/iu", "<{$tag}>$1</{$tag}>", $text);
    }
    
    /**
     * 날짜 형식 변환
     */
    public static function convertDateFormat($date, $outputFormat = 'Y-m-d') {
        // 다양한 입력 형식 지원
        $patterns = [
            '/^(\d{4})[.\/-](\d{1,2})[.\/-](\d{1,2})$/' => '$1-$2-$3',
            '/^(\d{1,2})[.\/-](\d{1,2})[.\/-](\d{4})$/' => '$3-$1-$2',
        ];
        
        foreach ($patterns as $pattern => $replacement) {
            if (preg_match($pattern, $date)) {
                $normalized = preg_replace($pattern, $replacement, $date);
                $timestamp = strtotime($normalized);
                if ($timestamp !== false) {
                    return date($outputFormat, $timestamp);
                }
            }
        }
        
        return $date;
    }
    
    /**
     * 안전한 파일명 생성
     */
    public static function sanitizeFilename($filename) {
        // 확장자 분리
        $info = pathinfo($filename);
        $name = $info['filename'];
        $ext = isset($info['extension']) ? '.' . $info['extension'] : '';
        
        // 특수문자 제거, 공백을 언더스코어로
        $name = preg_replace('/[^a-zA-Z0-9가-힣_-]/', '_', $name);
        $name = preg_replace('/_+/', '_', $name);
        
        return $name . $ext;
    }
    
    /**
     * 슬러그 생성 (URL 친화적 문자열)
     */
    public static function createSlug($text) {
        // 소문자 변환
        $text = strtolower($text);
        
        // 특수문자를 하이픈으로
        $text = preg_replace('/[^a-z0-9가-힣]+/u', '-', $text);
        
        // 연속된 하이픈을 하나로
        $text = preg_replace('/-+/', '-', $text);
        
        // 앞뒤 하이픈 제거
        return trim($text, '-');
    }
}

// 사용 예제
echo "=== 이메일 검증 ===\n";
var_dump(TextValidator::isValidEmail("user@example.com")); // true
var_dump(TextValidator::isValidEmail("invalid@")); // false

echo "\n=== 전화번호 포맷팅 ===\n";
echo TextValidator::formatPhone("01012345678") . "\n"; // 010-1234-5678
echo TextValidator::formatPhone("0212345678") . "\n"; // 02-1234-5678

echo "\n=== 비밀번호 강도 ===\n";
echo TextValidator::checkPasswordStrength("Pass123!") . "\n"; // 강력
echo TextValidator::checkPasswordStrength("password") . "\n"; // 약함

echo "\n=== 마스킹 ===\n";
echo TextValidator::maskEmail("john.doe@example.com") . "\n"; // jo***@example.com
echo TextValidator::maskPhone("010-1234-5678") . "\n"; // 010-****-5678
echo TextValidator::maskCardNumber("1234-5678-9012-3456") . "\n"; // ****-****-****-3456

echo "\n=== 텍스트 추출 ===\n";
$text = "연락처: user@example.com, 전화: 010-1234-5678, 가격: 10000원";
print_r(TextValidator::extractEmails($text));
echo TextValidator::extractNumbers($text) . "\n"; // 01012345678 10000

echo "\n=== 하이라이트 ===\n";
echo TextValidator::highlight("Hello World", "world") . "\n";
// Hello <mark>World</mark>

echo "\n=== 슬러그 생성 ===\n";
echo TextValidator::createSlug("안녕하세요! PHP 정규표현식") . "\n";
// 안녕하세요-php-정규표현식

?>

🐛 디버깅과 테스트

정규표현식은 복잡해서 디버깅이 어려울 수 있어.
효과적으로 테스트하고 디버깅하는 방법을 알아보자! 🔍

정규표현식 테스트 도구

에러 처리와 디버깅

<?php
/**
 * 정규표현식 에러 처리 헬퍼 함수
 */
function safePreg($function, ...$args) {
    $result = @$function(...$args);
    
    if ($result === false) {
        $error_code = preg_last_error();
        $errors = [
            PREG_NO_ERROR => '에러 없음',
            PREG_INTERNAL_ERROR => '내부 PCRE 에러',
            PREG_BACKTRACK_LIMIT_ERROR => '백트랙 제한 초과',
            PREG_RECURSION_LIMIT_ERROR => '재귀 제한 초과',
            PREG_BAD_UTF8_ERROR => '잘못된 UTF-8 데이터',
            PREG_BAD_UTF8_OFFSET_ERROR => '잘못된 UTF-8 오프셋',
        ];
        
        $error_msg = $errors[$error_code] ?? '알 수 없는 에러';
        throw new Exception("정규표현식 에러: {$error_msg}");
    }
    
    return $result;
}

// 사용 예제
try {
    $pattern = '/[a-z]+/';
    $text = "Hello World";
    $result = safePreg('preg_match', $pattern, $text);
    echo "매칭 결과: {$result}\n";
} catch (Exception $e) {
    echo "에러 발생: " . $e->getMessage() . "\n";
}

/**
 * 정규표현식 패턴 검증
 */
function validatePattern($pattern) {
    $test = @preg_match($pattern, '');
    
    if ($test === false) {
        $error = error_get_last();
        return [
            'valid' => false,
            'error' => $error['message'] ?? '알 수 없는 에러'
        ];
    }
    
    return ['valid' => true];
}

// 패턴 검증 예제
$patterns = [
    '/[a-z]+/' => '올바른 패턴',
    '/[a-z/' => '닫는 괄호 누락',
    '/(?P<name>[a-z]+)/' => '명명된 그룹',
];

foreach ($patterns as $pattern => $desc) {
    $result = validatePattern($pattern);
    echo "{$desc}: " . ($result['valid'] ? '✓' : '✗') . "\n";
    if (!$result['valid']) {
        echo "  에러: {$result['error']}\n";
    }
}

/**
 * 정규표현식 성능 측정
 */
function benchmarkRegex($pattern, $text, $iterations = 1000) {
    $start = microtime(true);
    
    for ($i = 0; $i < $iterations; $i++) {
        preg_match($pattern, $text);
    }
    
    $elapsed = microtime(true) - $start;
    $avg = $elapsed / $iterations * 1000; // 밀리초
    
    return [
        'total' => $elapsed,
        'average' => $avg,
        'iterations' => $iterations
    ];
}

// 성능 비교
$text = str_repeat("Hello World ", 100);
$patterns = [
    'Simple' => '/World/',
    'Complex' => '/\b[A-Z][a-z]+\b/',
    'Lookahead' => '/\b(?=\w{5})\w+\b/',
];

echo "\n=== 성능 벤치마크 ===\n";
foreach ($patterns as $name => $pattern) {
    $result = benchmarkRegex($pattern, $text);
    printf("%s: %.4f ms (평균)\n", $name, $result['average']);
}

/**
 * 유닛 테스트 예제
 */
class RegexTest {
    private $passed = 0;
    private $failed = 0;
    
    public function test($name, $pattern, $text, $expected) {
        $result = preg_match($pattern, $text);
        $success = ($result === 1) === $expected;
        
        if ($success) {
            $this->passed++;
            echo "✓ {$name}\n";
        } else {
            $this->failed++;
            echo "✗ {$name}\n";
            echo "  예상: " . ($expected ? '매칭' : '불일치') . "\n";
            echo "  실제: " . ($result ? '매칭' : '불일치') . "\n";
        }
    }
    
    public function summary() {
        $total = $this->passed + $this->failed;
        echo "\n=== 테스트 결과 ===\n";
        echo "통과: {$this->passed}/{$total}\n";
        echo "실패: {$this->failed}/{$total}\n";
    }
}

// 이메일 검증 테스트
$tester = new RegexTest();
$email_pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';

echo "\n=== 이메일 검증 테스트 ===\n";
$tester->test('유효한 이메일 1', $email_pattern, 'user@example.com', true);
$tester->test('유효한 이메일 2', $email_pattern, 'test.user@sub.domain.co.kr', true);
$tester->test('무효한 이메일 1', $email_pattern, 'invalid@', false);
$tester->test('무효한 이메일 2', $email_pattern, '@example.com', false);
$tester->test('무효한 이메일 3', $email_pattern, 'user@.com', false);

$tester->summary();
?>

📖 실무 패턴 라이브러리

자주 사용하는 정규표현식 패턴들을 모아서 라이브러리로 만들어봤어.
복사해서 바로 쓸 수 있게 주석도 자세히 달아뒀으니까 활용해봐! 📚

<?php
/**
 * 정규표현식 패턴 라이브러리
 */
class RegexPatterns {
    
    // ===== 기본 검증 =====
    
    /** 이메일 (기본) */
    const EMAIL = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';
    
    /** 이메일 (엄격) */
    const EMAIL_STRICT = '/^(?!.*\.\.)(?!.*\.$)[a-zA-Z0-9._%+-]{1,64}@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';
    
    /** URL (http/https) */
    const URL = '/^https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?$/';
    
    /** URL (프로토콜 선택) */
    const URL_FLEXIBLE = '/^(https?|ftp):\/\/[^\s]+$/';
    
    // ===== 전화번호 =====
    
    /** 한국 휴대폰 (하이픈 필수) */
    const PHONE_KR_MOBILE = '/^01[0-9]-\d{3,4}-\d{4}$/';
    
    /** 한국 휴대폰 (하이픈 선택) */
    const PHONE_KR_MOBILE_FLEX = '/^01[0-9]-?\d{3,4}-?\d{4}$/';
    
    /** 한국 일반전화 */
    const PHONE_KR_LANDLINE = '/^0\d{1,2}-\d{3,4}-\d{4}$/';
    
    /** 국제 전화번호 */
    const PHONE_INTERNATIONAL = '/^\+[1-9]\d{1,14}$/';
    
    // ===== 비밀번호 =====
    
    /** 비밀번호 (8자 이상, 영문+숫자) */
    const PASSWORD_MEDIUM = '/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/';
    
    /** 비밀번호 (8자 이상, 영문 대소문자+숫자+특수문자) */
    const PASSWORD_STRONG = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/';
    
    /** 비밀번호 (10자 이상, 모든 조건) */
    const PASSWORD_VERY_STRONG = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&#])[A-Za-z\d@$!%*?&#]{10,}$/';
    
    // ===== 날짜/시간 =====
    
    /** 날짜 (YYYY-MM-DD) */
    const DATE_ISO = '/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/';
    
    /** 날짜 (YYYY.MM.DD 또는 YYYY/MM/DD) */
    const DATE_FLEXIBLE = '/^\d{4}[.\/-](0[1-9]|1[0-2])[.\/-](0[1-9]|[12]\d|3[01])$/';
    
    /** 시간 (HH:MM) */
    const TIME_24H = '/^([01]\d|2[0-3]):[0-5]\d$/';
    
    /** 시간 (HH:MM:SS) */
    const TIME_24H_FULL = '/^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/';
    
    /** 날짜+시간 (ISO 8601) */
    const DATETIME_ISO = '/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/';
    
    // ===== 숫자 =====
    
    /** 정수 */
    const INTEGER = '/^-?\d+$/';
    
    /** 양의 정수 */
    const POSITIVE_INTEGER = '/^\d+$/';
    
    /** 소수 */
    const DECIMAL = '/^-?\d+(\.\d+)?$/';
    
    /** 통화 (원화) */
    const CURRENCY_KRW = '/^\d{1,3}(,\d{3})*원?$/';
    
    /** 통화 (달러) */
    const CURRENCY_USD = '/^\$\d{1,3}(,\d{3})*(\.\d{2})?$/';
    
    /** 퍼센트 */
    const PERCENTAGE = '/^\d+(\.\d+)?%$/';
    
    // ===== 한국 특화 =====
    
    /** 한글만 */
    const KOREAN_ONLY = '/^[가-힣]+$/u';
    
    /** 한글+영문 */
    const KOREAN_ENGLISH = '/^[가-힣a-zA-Z]+$/u';
    
    /** 한글+영문+숫자 */
    const KOREAN_ENGLISH_NUMBER = '/^[가-힣a-zA-Z0-9]+$/u';
    
    /** 우편번호 (5자리) */
    const ZIPCODE_KR = '/^\d{5}$/';
    
    /** 우편번호 (구형 6자리) */
    const ZIPCODE_KR_OLD = '/^\d{3}-?\d{3}$/';
    
    /** 주민등록번호 */
    const JUMIN = '/^\d{6}-?[1-4]\d{6}$/';
    
    /** 사업자등록번호 */
    const BUSINESS_NUMBER = '/^\d{3}-?\d{2}-?\d{5}$/';
    
    // ===== 신용카드 =====
    
    /** 신용카드 번호 */
    const CREDIT_CARD = '/^\d{4}-?\d{4}-?\d{4}-?\d{4}$/';
    
    /** Visa */
    const VISA = '/^4\d{3}-?\d{4}-?\d{4}-?\d{4}$/';
    
    /** MasterCard */
    const MASTERCARD = '/^5[1-5]\d{2}-?\d{4}-?\d{4}-?\d{4}$/';
    
    /** American Express */
    const AMEX = '/^3[47]\d{2}-?\d{6}-?\d{5}$/';
    
    // ===== IP 주소 =====
    
    /** IPv4 */
    const IPV4 = '/^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/';
    
    /** IPv6 (간단) */
    const IPV6 = '/^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/';
    
    // ===== 파일 =====
    
    /** 이미지 파일 확장자 */
    const IMAGE_FILE = '/\.(jpg|jpeg|png|gif|bmp|svg|webp)$/i';
    
    /** 문서 파일 확장자 */
    const DOCUMENT_FILE = '/\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt)$/i';
    
    /** 압축 파일 확장자 */
    const ARCHIVE_FILE = '/\.(zip|rar|7z|tar|gz)$/i';
    
    // ===== HTML/XML =====
    
    /** HTML 태그 */
    const HTML_TAG = '/<[^>]+>/';
    
    /** HTML 주석 */
    const HTML_COMMENT = '/<!--.*?-->/s';
    
    /** XML 태그 */
    const XML_TAG = '/<\/?[\w\s="\']+>/';
    
    // ===== 소셜미디어 =====
    
    /** 해시태그 */
    const HASHTAG = '/#[\w가-힣]+/u';
    
    /** 멘션 (@username) */
    const MENTION = '/@[\w가-힣]+/u';
    
    /** 트위터 사용자명 */
    const TWITTER_USERNAME = '/^@?[A-Za-z0-9_]{1,15}$/';
    
    /** 인스타그램 사용자명 */
    const INSTAGRAM_USERNAME = '/^@?[A-Za-z0-9_.]{1,30}$/';
    
    // ===== 기타 =====
    
    /** 16진수 색상 코드 */
    const HEX_COLOR = '/^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/';
    
    /** MAC 주소 */
    const MAC_ADDRESS = '/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/';
    
    /** UUID */
    const UUID = '/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i';
    
    /** Base64 */
    const BASE64 = '/^[A-Za-z0-9+\/]*={0,2}$/';
    
    /**
     * 패턴 검증 헬퍼
     */
    public static function validate($pattern, $text) {
        return preg_match($pattern, $text) === 1;
    }
    
    /**
     * 여러 패턴 중 하나라도 매칭되는지 확인
     */
    public static function validateAny($patterns, $text) {
        foreach ($patterns as $pattern) {
            if (self::validate($pattern, $text)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 모든 패턴이 매칭되는지 확인
     */
    public static function validateAll($patterns, $text) {
        foreach ($patterns as $pattern) {
            if (!self::validate($pattern, $text)) {
                return false;
            }
        }
        return true;
    }
}

// 사용 예제
echo "=== 패턴 라이브러리 사용 예제 ===\n\n";

// 이메일 검증
$email = "user@example.com";
echo "이메일 검증: ";
echo RegexPatterns::validate(RegexPatterns::EMAIL, $email) ? "✓" : "✗";
echo "\n";

// 전화번호 검증
$phone = "010-1234-5678";
echo "전화번호 검증: ";
echo RegexPatterns::validate(RegexPatterns::PHONE_KR_MOBILE, $phone) ? "✓" : "✗";
echo "\n";

// 비밀번호 강도 체크
$password = "Pass123!";
echo "비밀번호 강도: ";
if (RegexPatterns::validate(RegexPatterns::PASSWORD_VERY_STRONG, $password)) {
    echo "매우 강력";
} elseif (RegexPatterns::validate(RegexPatterns::PASSWORD_STRONG, $password)) {
    echo "강력";
} elseif (RegexPatterns::validate(RegexPatterns::PASSWORD_MEDIUM, $password)) {
    echo "보통";
} else {
    echo "약함";
}
echo "\n";

// 날짜 형식 체크
$date = "2024-03-15";
echo "날짜 형식: ";
echo RegexPatterns::validate(RegexPatterns::DATE_ISO, $date) ? "✓" : "✗";
echo "\n";

// 한글 이름 체크
$name = "홍길동";
echo "한글 이름: ";
echo RegexPatterns::validate(RegexPatterns::KOREAN_ONLY, $name) ? "✓" : "✗";
echo "\n";

// URL 체크
$url = "https://www.example.com";
echo "URL 형식: ";
echo RegexPatterns::validate(RegexPatterns::URL, $url) ? "✓" : "✗";
echo "\n";

?>

🎯 마무리하며

와, 여기까지 읽었다면 정말 대단해! 👏
PHP 정규표현식과 PCRE에 대해 꽤 많은 걸 배웠을 거야.

정규표현식은 처음엔 어렵게 느껴지지만, 계속 쓰다 보면 정말 강력한 도구라는 걸 알게 될 거야.
특히 텍스트 처리가 많은 웹 개발에서는 필수 스킬이라고 할 수 있지. 💪

재능넷 같은 플랫폼에서 프로젝트를 진행하거나,
개인 프로젝트를 만들 때도 오늘 배운 내용들이 큰 도움이 될 거야!

정규표현식은 연습이 정말 중요해.
오늘 배운 예제들을 직접 실행해보고, 자신만의 패턴도 만들어보면서 익혀봐!

막히는 부분이 있으면 regex101.com 같은 온라인 도구를 활용하면 좋아.
실시간으로 패턴을 테스트하고 설명도 볼 수 있거든. 🛠️

그리고 기억해, 모든 문제를 정규표현식으로 해결하려고 하지 마!
간단한 작업은 strpos(), str_replace() 같은 함수가 더 빠르고 읽기 쉬울 수 있어.

자, 이제 실전에서 마음껏 활용해봐!
화이팅! 🚀✨