정규표현식 완전 정복 2025: 기초부터 고급 패턴, 실전 활용까지 — 더 이상 두렵지 않다

import re

# 리터럴 매칭
print(re.findall(r'hello', 'hello world hello'))
# ['hello', 'hello']

. * + ? ^ $ | [ ] ( ) { } \

# 마침표를 리터럴로 매칭
print(re.findall(r'www\.example\.com', 'visit www.example.com'))
# ['www.example.com']

# [abc] — a, b, c 중 하나
re.findall(r'[aeiou]', 'hello world')
# ['e', 'o', 'o']

# [^abc] — a, b, c가 아닌 문자
re.findall(r'[^aeiou ]', 'hello world')
# ['h', 'l', 'l', 'w', 'r', 'l', 'd']

# [a-z] — 범위 지정
re.findall(r'[A-Z]', 'Hello World')
# ['H', 'W']

# [0-9a-fA-F] — 16진수 문자
re.findall(r'[0-9a-fA-F]+', 'color: #FF00AB')
# ['FF00AB']

# 전화번호 추출
text = "전화: 010-1234-5678, 팩스: 02-123-4567"
print(re.findall(r'\d{2,3}-\d{3,4}-\d{4}', text))
# ['010-1234-5678', '02-123-4567']

[:alpha:]  — 알파벳 문자
[:digit:]  — 숫자
[:alnum:]  — 알파벳 + 숫자
[:space:]  — 공백 문자
[:upper:]  — 대문자
[:lower:]  — 소문자
[:punct:]  — 구두점

# * (0회 이상)
re.findall(r'go*d', 'gd god good goood')
# ['gd', 'god', 'good', 'goood']

# + (1회 이상)
re.findall(r'go+d', 'gd god good goood')
# ['god', 'good', 'goood']

# ? (0 또는 1회)
re.findall(r'colou?r', 'color colour')
# ['color', 'colour']

# {n} — 정확히 n회
re.findall(r'\d{4}', '2025 is the year 12345')
# ['2025', '1234']

# {n,m} — n회 이상 m회 이하
re.findall(r'\d{2,4}', '1 12 123 1234 12345')
# ['12', '123', '1234', '1234']

# {n,} — n회 이상
re.findall(r'\d{3,}', '1 12 123 1234')
# ['123', '1234']

text = '<b>bold</b> and <i>italic</i>'

# 탐욕적 (기본)
print(re.findall(r'<.*>', text))
# ['<b>bold</b> and <i>italic</i>']  — 전체를 하나로 매칭!

# 게으른 (?를 추가)
print(re.findall(r'<.*?>', text))
# ['<b>', '</b>', '<i>', '</i>']  — 각 태그를 개별 매칭

// Java 예시
// 소유적 수량자 — 백트래킹 없음
String pattern = "a++b";  // 'a'를 최대한 소비 후 돌아가지 않음

# 기본 캡처 그룹
text = "2025-03-23"
match = re.match(r'(\d{4})-(\d{2})-(\d{2})', text)
if match:
    print(match.group(0))  # '2025-03-23' (전체 매치)
    print(match.group(1))  # '2025' (년)
    print(match.group(2))  # '03' (월)
    print(match.group(3))  # '23' (일)

# 비캡처 그룹
text = "http://example.com https://secure.com"
print(re.findall(r'(?:https?://)(\S+)', text))
# ['example.com', 'secure.com']  — 도메인만 캡처

# 명명된 그룹
text = "2025-03-23"
match = re.match(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})', text)
if match:
    print(match.group('year'))   # '2025'
    print(match.group('month'))  # '03'
    print(match.group('day'))    # '23'

# 중복 단어 찾기
text = "the the quick brown fox fox"
print(re.findall(r'\b(\w+)\s+\1\b', text))
# ['the', 'fox']

# HTML 태그 매칭 (같은 태그 이름)
html = "<div>content</div> <span>text</span>"
print(re.findall(r'<(\w+)>.*?</\1>', html))
# ['div', 'span']

# ^ — 문자열 시작
print(re.findall(r'^Hello', 'Hello World\nHello Again'))
# ['Hello']  — 첫 번째만

# $ — 문자열 끝
print(re.findall(r'end$', 'start to end'))
# ['end']

# 멀티라인 모드
print(re.findall(r'^Hello', 'Hello World\nHello Again', re.MULTILINE))
# ['Hello', 'Hello']  — 각 줄의 시작

text = "cat catfish concatenate scattered"

# \b 없이
print(re.findall(r'cat', text))
# ['cat', 'cat', 'cat', 'cat']

# \b로 정확한 단어만
print(re.findall(r'\bcat\b', text))
# ['cat']

# 단어 시작에서만
print(re.findall(r'\bcat\w*', text))
# ['cat', 'catfish', 'concatenate']

def validate_password(password):
    """
    비밀번호 규칙:
    - 8자 이상
    - 대문자 최소 1개
    - 소문자 최소 1개
    - 숫자 최소 1개
    - 특수문자 최소 1개
    """
    pattern = r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$'
    return bool(re.match(pattern, password))

print(validate_password("Abc123!@"))   # True
print(validate_password("abc123"))     # False (대문자, 특수문자 없음)
print(validate_password("Short1!"))    # False (8자 미만)

# 숫자에 쉼표 추가 (천 단위 구분)
def format_number(n):
    return re.sub(r'(?<=\d)(?=(\d{3})+(?!\d))', ',', str(n))

print(format_number(1234567890))
# '1,234,567,890'

# .js 파일이지만 .min.js가 아닌 것 찾기
files = ["app.js", "app.min.js", "utils.js", "vendor.min.js"]
pattern = r'^(?!.*\.min\.js$).*\.js$'
for f in files:
    if re.match(pattern, f):
        print(f)
# app.js
# utils.js

# 1. 기본 이메일 검증
email_basic = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

# 2. 이메일에서 도메인 추출
email_domain = r'@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'

# 3. Gmail 주소만 매칭
gmail_only = r'^[a-zA-Z0-9._%+-]+@gmail\.com$'

# 4. 기본 URL 매칭
url_basic = r'https?://[a-zA-Z0-9.-]+(?:/[^\s]*)?'

# 5. URL에서 도메인 추출
url_domain = r'https?://([^/\s]+)'

# 6. 쿼리 파라미터 추출
query_param = r'[?&]([^=&]+)=([^&]*)'

# 7. IPv4 주소
ipv4 = r'\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b'

# 8. 사설 IP 주소
private_ip = r'\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b'

# 9. 한국 휴대전화
kr_mobile = r'01[016789]-?\d{3,4}-?\d{4}'

# 10. 한국 일반전화
kr_phone = r'0\d{1,2}-?\d{3,4}-?\d{4}'

# 11. 국제 전화번호 (E.164)
intl_phone = r'\+\d{1,3}\d{4,14}'

# 12. YYYY-MM-DD
date_iso = r'\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])'

# 13. 다양한 날짜 형식
date_multi = r'\d{4}[/.-]\d{1,2}[/.-]\d{1,2}'

# 14. 24시간 시간
time_24h = r'(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?'

# 15. ISO 8601 날짜시간
iso_datetime = r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})'

# 16. HTML 태그
html_tag = r'<\/?[a-zA-Z][a-zA-Z0-9]*(?:\s[^>]*)?\/?>'

# 17. HEX 색상 코드
hex_color = r'#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b'

# 18. 시맨틱 버전 (SemVer)
semver = r'\bv?(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?(?:\+([\w.]+))?\b'

# 19. JSON 키
json_key = r'"([^"\\]*)"\s*:'

# 20. CSS 클래스 셀렉터
css_class = r'\.[a-zA-Z_][\w-]*'

# 21. 한글만 (자모 포함)
hangul = r'[\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F]+'

# 22. 한글 이름 (2-5자)
kr_name = r'[\uAC00-\uD7AF]{2,5}'

# 23. 일본어 히라가나
hiragana = r'[\u3040-\u309F]+'

# 24. 일본어 가타카나
katakana = r'[\u30A0-\u30FF]+'

# 25. 한자 (CJK 통합)
kanji = r'[\u4E00-\u9FFF]+'

# 26. 강한 비밀번호
strong_password = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$'

# 27. SQL 인젝션 의심 패턴
sql_injection = r"(?i)(?:union\s+select|or\s+1\s*=\s*1|drop\s+table|insert\s+into)"

# 28. XSS 의심 패턴
xss_pattern = r'(?i)<script[^>]*>.*?</script>'

# 29. 공백 정규화 (연속 공백을 하나로)
text = "too    many   spaces"
print(re.sub(r'\s+', ' ', text))
# 'too many spaces'

# 30. CSV 필드 추출 (쉼표 구분, 따옴표 지원)
csv_field = r'(?:"([^"]*)"|([^,]*))'

// 리터럴 방식
const re1 = /hello/gi;

// 생성자 방식
const re2 = new RegExp('hello', 'gi');

// 주요 메서드
'hello world'.match(/hello/);       // ['hello']
'hello world'.replace(/hello/, 'hi'); // 'hi world'
/hello/.test('hello world');         // true

// Named Groups (ES2018+)
const match = '2025-03-23'.match(
  /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
);
console.log(match.groups.year);  // '2025'

// matchAll (ES2020+)
const text = 'cat bat sat';
for (const m of text.matchAll(/[a-z]at/g)) {
  console.log(m[0], m.index);
}

// Lookbehind (ES2018+)
'$100 200 $300'.match(/(?<=\$)\d+/g);  // ['100', '300']

import re

# 기본 메서드
re.match(r'^hello', 'hello world')   # 시작에서만 매칭
re.search(r'hello', 'say hello')     # 어디서든 매칭
re.findall(r'\d+', 'a1 b2 c3')      # 모든 매칭 리스트
re.sub(r'\d+', 'N', 'a1 b2')        # 치환: 'aN bN'

# 컴파일 (반복 사용 시 성능 향상)
pattern = re.compile(r'\d{3}-\d{4}')
pattern.findall('010-1234-5678')

# 플래그
re.IGNORECASE  # 대소문자 무시
re.MULTILINE   # ^ $를 각 줄에 적용
re.DOTALL      # .이 개행도 매칭
re.VERBOSE     # 주석과 공백 허용

# VERBOSE 예시
phone_re = re.compile(r'''
    (\d{3})     # 지역번호
    [-.\s]?     # 구분자
    (\d{3,4})   # 중간 번호
    [-.\s]?     # 구분자
    (\d{4})     # 마지막 번호
''', re.VERBOSE)

import java.util.regex.*;

// 기본 사용
Pattern pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
Matcher matcher = pattern.matcher("Date: 2025-03-23");
if (matcher.find()) {
    System.out.println(matcher.group());  // "2025-03-23"
}

// Named Groups
Pattern datePattern = Pattern.compile(
    "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
);
Matcher m = datePattern.matcher("2025-03-23");
if (m.find()) {
    System.out.println(m.group("year"));  // "2025"
}

// String 메서드
"hello world".matches("hello.*");   // true
"a1b2c3".replaceAll("\\d", "N");   // "aNbNcN"
"a,b,,c".split(",", -1);           // ["a", "b", "", "c"]

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 컴파일
    re := regexp.MustCompile(`\d{4}-\d{2}-\d{2}`)

    // 매칭 확인
    fmt.Println(re.MatchString("2025-03-23"))  // true

    // 찾기
    fmt.Println(re.FindString("Date: 2025-03-23"))  // "2025-03-23"

    // 모두 찾기
    fmt.Println(re.FindAllString("2025-03-23 and 2025-12-31", -1))

    // Named Groups
    re2 := regexp.MustCompile(
        `(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`,
    )
    match := re2.FindStringSubmatch("2025-03-23")
    for i, name := range re2.SubexpNames() {
        if name != "" {
            fmt.Printf("%s: %s\n", name, match[i])
        }
    }
}

# 정상적인 백트래킹
# 패턴: a*b
# 입력: "aaac"
# 시도: "aaa" + b? 실패 → "aa" + b? 실패 → "a" + b? 실패 → "" + b? 실패
# 총 4번 백트래킹 — 문제 없음

import time

# 위험한 패턴!
dangerous_pattern = r'(a+)+b'
safe_pattern = r'a+b'

# 짧은 입력 — 둘 다 빠름
text_short = 'a' * 10 + 'c'

# 긴 입력 — 위험한 패턴은 지수적 시간 소요
text_long = 'a' * 25 + 'c'

start = time.time()
re.match(safe_pattern, text_long)
print(f"안전한 패턴: {time.time() - start:.4f}s")

# 주의: 아래 코드는 매우 오래 걸릴 수 있음!
# start = time.time()
# re.match(dangerous_pattern, text_long)
# print(f"위험한 패턴: {time.time() - start:.4f}s")

# 1. 중첩된 수량자
r'(a+)+'      # 위험!
r'(a*)*'      # 위험!
r'(a+)*'      # 위험!

# 2. 겹치는 대안
r'(a|a)+'     # 위험!
r'(\d+|\d+\.)+' # 위험!

# 3. 안전한 대체 패턴
r'a+'         # (a+)+ 대신
r'a*'         # (a*)* 대신
r'\d+\.?'     # (\d+|\d+\.)+ 대신

# Python에서 타임아웃 설정
import signal

def timeout_handler(signum, frame):
    raise TimeoutError("Regex timeout!")

signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(1)  # 1초 타임아웃

try:
    re.match(r'(a+)+b', 'a' * 30 + 'c')
except TimeoutError:
    print("정규표현식 실행이 시간 초과되었습니다.")
finally:
    signal.alarm(0)

# grep 기본 사용
grep -E 'error|warning' /var/log/syslog
grep -P '(?<=user:)\w+' access.log  # Perl 호환 정규식

# ripgrep (rg) — 더 빠른 대안
rg 'TODO|FIXME' --type py
rg '\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b' access.log
rg -e 'pattern1' -e 'pattern2' .  # 여러 패턴

# sed — 스트림 편집기
# 날짜 형식 변환: 2025/03/23 → 2025-03-23
echo "2025/03/23" | sed 's/\//-/g'

# 이메일 주소 마스킹
echo "user@example.com" | sed 's/\(.\).*@/\1***@/'
# u***@example.com

# awk — 패턴 매칭 + 처리
# 200 상태코드인 로그만 출력
awk '/HTTP\/[0-9.]+" 200/' access.log

# IP별 요청 수 집계
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head