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

import re

# Literal matching
print(re.findall(r'hello', 'hello world hello'))
# ['hello', 'hello']

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

# Match a literal period
print(re.findall(r'www\.example\.com', 'visit www.example.com'))
# ['www.example.com']

# [abc] — one of a, b, or c
re.findall(r'[aeiou]', 'hello world')
# ['e', 'o', 'o']

# [^abc] — any character NOT a, b, or c
re.findall(r'[^aeiou ]', 'hello world')
# ['h', 'l', 'l', 'w', 'r', 'l', 'd']

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

# [0-9a-fA-F] — hex characters
re.findall(r'[0-9a-fA-F]+', 'color: #FF00AB')
# ['FF00AB']

# Extract phone numbers
text = "Call 555-1234 or 800-555-6789"
print(re.findall(r'\d{3}-\d{3,4}(?:-\d{4})?', text))
# ['555-1234', '800-555-6789']

[:alpha:]  — Alphabetic characters
[:digit:]  — Digits
[:alnum:]  — Alphanumeric
[:space:]  — Whitespace
[:upper:]  — Uppercase letters
[:lower:]  — Lowercase letters
[:punct:]  — Punctuation

# * (0 or more)
re.findall(r'go*d', 'gd god good goood')
# ['gd', 'god', 'good', 'goood']

# + (1 or more)
re.findall(r'go+d', 'gd god good goood')
# ['god', 'good', 'goood']

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

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

# {n,m} — between n and m times
re.findall(r'\d{2,4}', '1 12 123 1234 12345')
# ['12', '123', '1234', '1234']

# {n,} — n or more times
re.findall(r'\d{3,}', '1 12 123 1234')
# ['123', '1234']

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

# Greedy (default)
print(re.findall(r'<.*>', text))
# ['<b>bold</b> and <i>italic</i>']  — matches everything!

# Lazy (add ?)
print(re.findall(r'<.*?>', text))
# ['<b>', '</b>', '<i>', '</i>']  — matches each tag

// Java example
// Possessive quantifier — no backtracking
String pattern = "a++b";  // Consumes all 'a's, never gives back

# Basic capturing group
text = "2025-03-23"
match = re.match(r'(\d{4})-(\d{2})-(\d{2})', text)
if match:
    print(match.group(0))  # '2025-03-23' (full match)
    print(match.group(1))  # '2025' (year)
    print(match.group(2))  # '03' (month)
    print(match.group(3))  # '23' (day)

# Non-capturing group
text = "http://example.com https://secure.com"
print(re.findall(r'(?:https?://)(\S+)', text))
# ['example.com', 'secure.com']  — captures only the domain

# Named groups
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'

# Find duplicate words
text = "the the quick brown fox fox"
print(re.findall(r'\b(\w+)\s+\1\b', text))
# ['the', 'fox']

# Match HTML tags (same tag name)
html = "<div>content</div> <span>text</span>"
print(re.findall(r'<(\w+)>.*?</\1>', html))
# ['div', 'span']

# ^ — start of string
print(re.findall(r'^Hello', 'Hello World\nHello Again'))
# ['Hello']  — only the first

# $ — end of string
print(re.findall(r'end$', 'start to end'))
# ['end']

# Multiline mode
print(re.findall(r'^Hello', 'Hello World\nHello Again', re.MULTILINE))
# ['Hello', 'Hello']  — start of each line

text = "cat catfish concatenate scattered"

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

# With \b for exact word
print(re.findall(r'\bcat\b', text))
# ['cat']

# Word start only
print(re.findall(r'\bcat\w*', text))
# ['cat', 'catfish', 'concatenate']

def validate_password(password):
    """
    Password rules:
    - At least 8 characters
    - At least 1 uppercase letter
    - At least 1 lowercase letter
    - At least 1 digit
    - At least 1 special character
    """
    pattern = r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$'
    return bool(re.match(pattern, password))

print(validate_password("Abc123!@"))   # True
print(validate_password("abc123"))     # False (no uppercase, no special)
print(validate_password("Short1!"))    # False (under 8 chars)

# Add commas to numbers (thousands separator)
def format_number(n):
    return re.sub(r'(?<=\d)(?=(\d{3})+(?!\d))', ',', str(n))

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

# Find .js files that are NOT .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. Basic email validation
email_basic = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

# 2. Extract domain from email
email_domain = r'@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'

# 3. Match Gmail addresses only
gmail_only = r'^[a-zA-Z0-9._%+-]+@gmail\.com$'

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

# 5. Extract domain from URL
url_domain = r'https?://([^/\s]+)'

# 6. Extract query parameters
query_param = r'[?&]([^=&]+)=([^&]*)'

# 7. IPv4 address
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. Private IP addresses
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. US phone number
us_phone = r'(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'

# 10. International E.164 format
intl_phone = r'\+\d{1,3}\d{4,14}'

# 11. UK phone number
uk_phone = r'(?:\+44|0)\d{4}[\s-]?\d{6}'

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

# 13. Multiple date formats
date_multi = r'\d{4}[/.-]\d{1,2}[/.-]\d{1,2}'

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

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

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

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

# 18. Semantic versioning (SemVer)
semver = r'\bv?(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?(?:\+([\w.]+))?\b'

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

# 20. CSS class selectors
css_class = r'\.[a-zA-Z_][\w-]*'

# 21. Korean characters (Hangul)
hangul = r'[\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F]+'

# 22. Japanese Hiragana
hiragana = r'[\u3040-\u309F]+'

# 23. Japanese Katakana
katakana = r'[\u30A0-\u30FF]+'

# 24. CJK Unified Ideographs (Kanji/Hanzi)
cjk = r'[\u4E00-\u9FFF]+'

# 25. Any CJK character
cjk_all = r'[\u3000-\u9FFF\uAC00-\uD7AF]+'

# 26. Strong password
strong_password = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$'

# 27. SQL injection suspicious patterns
sql_injection = r"(?i)(?:union\s+select|or\s+1\s*=\s*1|drop\s+table|insert\s+into)"

# 28. XSS suspicious patterns
xss_pattern = r'(?i)<script[^>]*>.*?</script>'

# 29. Normalize whitespace (collapse multiple spaces)
text = "too    many   spaces"
print(re.sub(r'\s+', ' ', text))
# 'too many spaces'

# 30. CSV field extraction (comma-separated, quoted support)
csv_field = r'(?:"([^"]*)"|([^,]*))'

// Literal syntax
const re1 = /hello/gi;

// Constructor syntax
const re2 = new RegExp('hello', 'gi');

// Key methods
'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

# Core methods
re.match(r'^hello', 'hello world')   # Match at start only
re.search(r'hello', 'say hello')     # Match anywhere
re.findall(r'\d+', 'a1 b2 c3')      # All matches as list
re.sub(r'\d+', 'N', 'a1 b2')        # Substitution: 'aN bN'

# Compilation (performance boost for repeated use)
pattern = re.compile(r'\d{3}-\d{4}')
pattern.findall('555-1234-5678')

# Flags
re.IGNORECASE  # Case-insensitive
re.MULTILINE   # ^ and $ match line boundaries
re.DOTALL      # . matches newlines too
re.VERBOSE     # Allow comments and whitespace

# VERBOSE example
phone_re = re.compile(r'''
    (\d{3})     # area code
    [-.\s]?     # separator
    (\d{3,4})   # middle digits
    [-.\s]?     # separator
    (\d{4})     # last digits
''', re.VERBOSE)

import java.util.regex.*;

// Basic usage
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 methods
"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() {
    // Compile
    re := regexp.MustCompile(`\d{4}-\d{2}-\d{2}`)

    // Match check
    fmt.Println(re.MatchString("2025-03-23"))  // true

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

    // Find all
    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])
        }
    }
}

# Normal backtracking
# Pattern: a*b
# Input: "aaac"
# Tries: "aaa" + b? fail -> "aa" + b? fail -> "a" + b? fail -> "" + b? fail
# 4 backtracks total — no problem

import time

# Dangerous pattern!
dangerous_pattern = r'(a+)+b'
safe_pattern = r'a+b'

# Short input — both fast
text_short = 'a' * 10 + 'c'

# Long input — dangerous pattern takes exponential time
text_long = 'a' * 25 + 'c'

start = time.time()
re.match(safe_pattern, text_long)
print(f"Safe pattern: {time.time() - start:.4f}s")

# WARNING: The following may take a very long time!
# start = time.time()
# re.match(dangerous_pattern, text_long)
# print(f"Dangerous pattern: {time.time() - start:.4f}s")

# 1. Nested quantifiers
r'(a+)+'      # Dangerous!
r'(a*)*'      # Dangerous!
r'(a+)*'      # Dangerous!

# 2. Overlapping alternatives
r'(a|a)+'     # Dangerous!
r'(\d+|\d+\.)+' # Dangerous!

# 3. Safe replacements
r'a+'         # Instead of (a+)+
r'a*'         # Instead of (a*)*
r'\d+\.?'     # Instead of (\d+|\d+\.)+

# Timeout in Python
import signal

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

signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(1)  # 1 second timeout

try:
    re.match(r'(a+)+b', 'a' * 30 + 'c')
except TimeoutError:
    print("Regex execution timed out.")
finally:
    signal.alarm(0)

# grep basics
grep -E 'error|warning' /var/log/syslog
grep -P '(?<=user:)\w+' access.log  # Perl-compatible regex

# ripgrep (rg) — faster alternative
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' .  # Multiple patterns

# sed — stream editor
# Convert date format: 2025/03/23 -> 2025-03-23
echo "2025/03/23" | sed 's/\//-/g'

# Mask email address
echo "user@example.com" | sed 's/\(.\).*@/\1***@/'
# u***@example.com

# awk — pattern matching + processing
# Print only 200 status code logs
awk '/HTTP\/[0-9.]+" 200/' access.log

# Count requests per IP
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head