📚 regexp 패키지 기본기 다지기

패키지 임포트부터 시작!

일단 Go에서 정규표현식 쓰려면 regexp 패키지를 임포트해야겠지? 기본 중의 기본이야!

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 정규표현식 패턴 컴파일
    pattern := `\d+` // 숫자 하나 이상 매칭
    re, err := regexp.Compile(pattern)
    if err != nil {
        fmt.Println("정규표현식 컴파일 에러:", err)
        return
    }
    
    text := "내 전화번호는 010-1234-5678이야"
    result := re.FindString(text)
    fmt.Println("찾은 숫자:", result) // 출력: 010
}

위 코드에서 regexp.Compile() 함수가 핵심이야. 이 함수는 정규표현식 패턴 문자열을 받아서 Regexp 객체로 컴파일해줘. 컴파일된 객체는 재사용할 수 있어서 성능상 이득이 크지!

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

func isValidEmail(email string) bool {
    return emailRegex.MatchString(email)
}

// 사용
fmt.Println(isValidEmail("test@example.com"))    // true
fmt.Println(isValidEmail("잘못된이메일"))          // false

주요 메서드들 총정리 🎓

regexp 패키지에는 진짜 많은 메서드들이 있는데, 자주 쓰는 것들만 정리해볼게!

각 메서드마다 용도가 명확해서 상황에 맞게 골라 쓰면 돼ㅋㅋ 이제 하나씩 실전 예제로 파헤쳐보자!

🔍 실전 패턴 매칭 테크닉

1. 기본 매칭 - MatchString

가장 기본적인 거부터 시작해보자. MatchString은 그냥 "이 문자열이 패턴이랑 맞아?"를 물어보는 거야. true/false만 돌려줘서 간단명료함ㅋㅋ

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 한글 이름 패턴 (2-4글자)
    namePattern := regexp.MustCompile(`^[가-힣]{2,4}$`)
    
    names := []string{"김철수", "이", "박영희짱짱맨", "홍길동"}
    
    for _, name := range names {
        if namePattern.MatchString(name) {
            fmt.Printf("%s: ✅ 유효한 이름\n", name)
        } else {
            fmt.Printf("%s: ❌ 유효하지 않은 이름\n", name)
        }
    }
}

// 출력:
// 김철수: ✅ 유효한 이름
// 이: ❌ 유효하지 않은 이름
// 박영희짱짱맨: ❌ 유효하지 않은 이름
// 홍길동: ✅ 유효한 이름

여기서 ^[가-힣]{2,4}$ 패턴을 보면:
• ^: 문자열의 시작
• [가-힣]: 한글 자모 범위
• {2,4}: 2개 이상 4개 이하
• $: 문자열의 끝

2. 문자열 찾기 - FindString & FindAllString

이제 좀 더 재밌는 거 해보자! 텍스트에서 특정 패턴을 찾아내는 거야. FindString은 첫 번째 매칭만, FindAllString은 모든 매칭을 찾아줘 🎯

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := `
    문의사항은 support@example.com으로 보내주세요.
    마케팅 담당자: marketing@company.co.kr
    개발팀: dev@tech-startup.io
    잘못된형식@
    `
    
    // 이메일 패턴
    emailPattern := regexp.MustCompile(`[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`)
    
    // 첫 번째 이메일만 찾기
    firstEmail := emailPattern.FindString(text)
    fmt.Println("첫 번째 이메일:", firstEmail)
    
    // 모든 이메일 찾기
    allEmails := emailPattern.FindAllString(text, -1) // -1은 제한 없이 모두 찾기
    fmt.Println("\n모든 이메일:")
    for i, email := range allEmails {
        fmt.Printf("%d. %s\n", i+1, email)
    }
}

// 출력:
// 첫 번째 이메일: support@example.com
//
// 모든 이메일:
// 1. support@example.com
// 2. marketing@company.co.kr
// 3. dev@tech-startup.io

FindAllString의 두 번째 파라미터가 중요한데, 이게 찾을 최대 개수야. -1을 넣으면 제한 없이 다 찾고, 양수를 넣으면 그 개수만큼만 찾아줘!

3. 서브매치로 그룹 캡처하기 🎣

이게 진짜 꿀기능인데ㅋㅋㅋ 정규표현식에서 괄호 ()로 묶으면 그 부분을 따로 캡처할 수 있어. 예를 들어 전화번호에서 지역번호, 국번, 번호를 각각 분리하고 싶을 때 쓰면 딱이야!

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "연락처: 010-1234-5678, 02-987-6543"
    
    // 괄호로 그룹 지정
    phonePattern := regexp.MustCompile(`(\d{2,3})-(\d{3,4})-(\d{4})`)
    
    // FindStringSubmatch: 첫 번째 매칭과 서브매치 반환
    match := phonePattern.FindStringSubmatch(text)
    if match != nil {
        fmt.Println("전체 매칭:", match[0])
        fmt.Println("첫 번째 그룹 (지역번호):", match[1])
        fmt.Println("두 번째 그룹 (국번):", match[2])
        fmt.Println("세 번째 그룹 (번호):", match[3])
    }
    
    fmt.Println("\n--- 모든 전화번호 파싱 ---")
    
    // FindAllStringSubmatch: 모든 매칭과 서브매치 반환
    allMatches := phonePattern.FindAllStringSubmatch(text, -1)
    for i, match := range allMatches {
        fmt.Printf("\n전화번호 %d:\n", i+1)
        fmt.Printf("  전체: %s\n", match[0])
        fmt.Printf("  지역번호: %s\n", match[1])
        fmt.Printf("  국번: %s\n", match[2])
        fmt.Printf("  번호: %s\n", match[3])
    }
}

// 출력:
// 전체 매칭: 010-1234-5678
// 첫 번째 그룹 (지역번호): 010
// 두 번째 그룹 (국번): 1234
// 세 번째 그룹 (번호): 5678
//
// --- 모든 전화번호 파싱 ---
//
// 전화번호 1:
//   전체: 010-1234-5678
//   지역번호: 010
//   국번: 1234
//   번호: 5678
//
// 전화번호 2:
//   전체: 02-987-6543
//   지역번호: 02
//   국번: 987
//   번호: 6543

서브매치 결과는 슬라이스로 반환되는데, 인덱스 0은 전체 매칭이고, 1부터는 각 그룹이야. 이거 진짜 유용해서 URL 파싱이나 로그 분석할 때 엄청 많이 써!

4. 명명된 그룹으로 가독성 UP! 📝

그룹이 많아지면 match[1], match[2] 이런 식으로 쓰면 헷갈리잖아? Go의 regexp는 명명된 그룹(Named Groups)을 지원해서 이름으로 접근할 수 있어!

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "생년월일: 1990-05-15"
    
    // ?P<이름> 문법으로 그룹에 이름 지정
    datePattern := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
    
    match := datePattern.FindStringSubmatch(text)
    if match == nil {
        fmt.Println("매칭 실패")
        return
    }
    
    // 그룹 이름으로 인덱스 찾기
    names := datePattern.SubexpNames()
    result := make(map[string]string)
    
    for i, name := range names {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }
    
    fmt.Println("연도:", result["year"])
    fmt.Println("월:", result["month"])
    fmt.Println("일:", result["day"])
}

// 출력:
// 연도: 1990
// 월: 05
// 일: 15

SubexpNames() 메서드가 그룹 이름들을 반환해줘서 맵으로 만들면 훨씬 직관적이지? 코드 유지보수할 때도 "아 이게 연도구나" 하고 바로 알 수 있어서 좋아ㅋㅋ

✏️ 문자열 치환과 변환

ReplaceAllString으로 간단 치환

이제 찾은 패턴을 다른 문자열로 바꿔보자! 가장 기본적인 ReplaceAllString부터 시작할게.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := `
    고객정보:
    이름: 김철수
    주민번호: 901234-1234567
    전화번호: 010-1234-5678
    이메일: customer@email.com
    `
    
    // 주민번호 뒷자리 마스킹
    ssnPattern := regexp.MustCompile(`(\d{6})-(\d{7})`)
    masked := ssnPattern.ReplaceAllString(text, "$1-*******")
    
    // 전화번호 중간자리 마스킹
    phonePattern := regexp.MustCompile(`(\d{3})-(\d{4})-(\d{4})`)
    masked = phonePattern.ReplaceAllString(masked, "$1-****-$3")
    
    // 이메일 아이디 부분 마스킹
    emailPattern := regexp.MustCompile(`([a-zA-Z0-9._%+-]{1,3})[a-zA-Z0-9._%+-]*@`)
    masked = emailPattern.ReplaceAllString(masked, "$1***@")
    
    fmt.Println(masked)
}

// 출력:
// 고객정보:
// 이름: 김철수
// 주민번호: 901234-*******
// 전화번호: 010-****-5678
// 이메일: cus***@email.com

여기서 $1, $2, $3은 캡처된 그룹을 참조하는 거야. $1은 첫 번째 괄호, $2는 두 번째 괄호... 이런 식이지! 개인정보 처리할 때 진짜 유용해 🔒

ReplaceAllStringFunc로 동적 치환

근데 단순 치환 말고 좀 더 복잡한 로직이 필요할 때가 있잖아? 그럴 땐 ReplaceAllStringFunc를 써! 함수를 넘겨서 매칭된 문자열마다 다른 처리를 할 수 있어.

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    text := `
    참고 사이트:
    https://golang.org
    http://example.com
    www.github.com
    `
    
    urlPattern := regexp.MustCompile(`https?://[^\s]+|www\.[^\s]+`)
    
    // 각 URL을 HTML 링크로 변환
    result := urlPattern.ReplaceAllStringFunc(text, func(url string) string {
        // www로 시작하면 http:// 추가
        if strings.HasPrefix(url, "www") {
            url = "http://" + url
        }
        return fmt.Sprintf(`<a href="%s">%s</a>`, url, url)
    })
    
    fmt.Println(result)
}

// 출력:
// 참고 사이트:
// <a href="https://golang.org">https://golang.org</a>
// <a href="http://example.com">http://example.com</a>
// <a href="http://www.github.com">http://www.github.com</a>

이렇게 하면 매칭된 각 문자열에 대해 커스텀 로직을 적용할 수 있어. 마크다운 파서 만들 때나 텍스트 전처리할 때 엄청 유용하지ㅋㅋ

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

자 이제 본격적으로 정규표현식 문법을 파헤쳐보자! 처음엔 복잡해 보이지만 하나씩 알고 나면 진짜 쉬워ㅋㅋ

기본 메타문자들

수량자(Quantifiers) 상세 가이드

수량자는 패턴이 몇 번 반복되는지를 지정하는 거야. 이거 제대로 알아야 원하는 패턴을 정확히 잡을 수 있어!

package main

import (
    "fmt"
    "regexp"
)

func main() {
    patterns := map[string]string{
        `\d{3}`:      "정확히 3자리 숫자",
        `\d{3,}`:     "3자리 이상 숫자",
        `\d{3,5}`:    "3~5자리 숫자",
        `\d*`:        "0개 이상의 숫자",
        `\d+`:        "1개 이상의 숫자",
        `\d?`:        "0개 또는 1개의 숫자",
    }
    
    testStrings := []string{"1", "12", "123", "1234", "12345", "123456"}
    
    for pattern, desc := range patterns {
        fmt.Printf("\n패턴: %s (%s)\n", pattern, desc)
        re := regexp.MustCompile("^" + pattern + "$")
        
        for _, test := range testStrings {
            if re.MatchString(test) {
                fmt.Printf("  ✅ %s\n", test)
            }
        }
    }
}

문자 클래스와 단축 표현

자주 쓰는 패턴들은 단축 표현이 있어서 편하게 쓸 수 있어! 이거 외워두면 코드가 훨씬 간결해져ㅋㅋ

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 아이디 검증: 영문자로 시작, 영문자+숫자+언더스코어, 4-12자
    usernamePattern := regexp.MustCompile(`^[a-zA-Z]\w{3,11}$`)
    
    // 비밀번호 검증: 최소 8자, 영문+숫자+특수문자 포함
    passwordPattern := regexp.MustCompile(`^(?=.*[a-zA-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$`)
    
    // 공백 제거
    whitespacePattern := regexp.MustCompile(`\s+`)
    
    // 테스트
    usernames := []string{"user123", "1user", "ab", "valid_user_99"}
    fmt.Println("=== 아이디 검증 ===")
    for _, username := range usernames {
        if usernamePattern.MatchString(username) {
            fmt.Printf("✅ %s: 유효\n", username)
        } else {
            fmt.Printf("❌ %s: 유효하지 않음\n", username)
        }
    }
    
    // 공백 제거 예제
    text := "  여러   공백이    있는   텍스트  "
    cleaned := whitespacePattern.ReplaceAllString(text, " ")
    fmt.Printf("\n원본: '%s'\n", text)
    fmt.Printf("정리: '%s'\n", cleaned)
}

// 출력:
// === 아이디 검증 ===
// ✅ user123: 유효
// ❌ 1user: 유효하지 않음
// ❌ ab: 유효하지 않음
// ✅ valid_user_99: 유효
//
// 원본: '  여러   공백이    있는   텍스트  '
// 정리: ' 여러 공백이 있는 텍스트 '

Lookahead와 Lookbehind (전방탐색/후방탐색)

이건 좀 고급 기능인데, 특정 패턴 앞이나 뒤에 있는 걸 찾을 때 써. 근데 주의할 점! Go의 RE2 엔진은 lookbehind를 지원 안 해 😢 lookahead만 가능해!

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "가격: 10000원, 할인가: 5000원, 배송비: 3000원"
    
    // 긍정 전방탐색 (?=pattern): 뒤에 '원'이 오는 숫자만 매칭
    pricePattern := regexp.MustCompile(`\d+(?=원)`)
    prices := pricePattern.FindAllString(text, -1)
    
    fmt.Println("찾은 가격들:")
    for _, price := range prices {
        fmt.Println("  -", price)
    }
    
    // 부정 전방탐색 (?!pattern): 뒤에 '원'이 오지 않는 숫자
    nonPricePattern := regexp.MustCompile(`\d+(?!원)`)
    fmt.Println("\n'원'이 붙지 않은 숫자:")
    fmt.Println(nonPricePattern.FindAllString("주문번호: 12345, 가격: 10000원", -1))
}

// 출력:
// 찾은 가격들:
//   - 10000
//   - 5000
//   - 3000
//
// '원'이 붙지 않은 숫자:
// [12345 1000]

⚡ 성능 최적화 팁

정규표현식은 강력하지만 잘못 쓰면 성능 저하의 주범이 될 수 있어. 실전에서 꼭 알아야 할 최적화 팁들을 정리해볼게!

1. 정규표현식 컴파일 재사용

func validateEmails(emails []string) []bool {
    results := make([]bool, len(emails))
    for i, email := range emails {
        // 매번 컴파일 - 비효율적!
        re := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
        results[i] = re.MatchString(email)
    }
    return results
}

// 전역 변수로 한 번만 컴파일
var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

func validateEmails(emails []string) []bool {
    results := make([]bool, len(emails))
    for i, email := range emails {
        // 컴파일된 객체 재사용 - 효율적!
        results[i] = emailRegex.MatchString(email)
    }
    return results
}

2. 적절한 메서드 선택

용도에 맞는 메서드를 선택하는 것도 중요해! 불필요하게 복잡한 메서드를 쓰면 성능 낭비야.

3. 패턴 최적화 기법

package main

import (
    "fmt"
    "regexp"
    "time"
)

func benchmark(name string, pattern string, text string, iterations int) {
    re := regexp.MustCompile(pattern)
    
    start := time.Now()
    for i := 0; i < iterations; i++ {
        re.MatchString(text)
    }
    elapsed := time.Since(start)
    
    fmt.Printf("%s: %v\n", name, elapsed)
}

func main() {
    text := "test@example.com"
    iterations := 100000
    
    fmt.Println("=== 패턴 최적화 벤치마크 ===\n")
    
    // 비효율적인 패턴: 백트래킹 많음
    benchmark(
        "비효율적",
        `^.*@.*\..*$`,
        text,
        iterations,
    )
    
    // 효율적인 패턴: 명확한 문자 클래스 사용
    benchmark(
        "효율적",
        `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`,
        text,
        iterations,
    )
    
    // 더 효율적: 불필요한 캡처 그룹 제거
    benchmark(
        "더 효율적",
        `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`,
        text,
        iterations,
    )
}

// 출력 예시:
// === 패턴 최적화 벤치마크 ===
//
// 비효율적: 45.2ms
// 효율적: 28.7ms
// 더 효율적: 27.1ms

4. 대용량 텍스트 처리

큰 파일이나 스트림을 처리할 때는 전략이 필요해! 한 번에 다 읽지 말고 청크 단위로 처리하는 게 좋아.

package main

import (
    "bufio"
    "fmt"
    "os"
    "regexp"
)

func processLargeLogFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()
    
    // 에러 패턴
    errorPattern := regexp.MustCompile(`ERROR|FATAL|CRITICAL`)
    
    scanner := bufio.NewScanner(file)
    lineNum := 0
    errorCount := 0
    
    // 라인별로 처리 - 메모리 효율적!
    for scanner.Scan() {
        lineNum++
        line := scanner.Text()
        
        if errorPattern.MatchString(line) {
            errorCount++
            fmt.Printf("Line %d: %s\n", lineNum, line)
        }
    }
    
    if err := scanner.Err(); err != nil {
        return err
    }
    
    fmt.Printf("\n총 %d개의 에러 발견 (전체 %d 라인)\n", errorCount, lineNum)
    return nil
}

func main() {
    // 사용 예시
    // processLargeLogFile("/var/log/application.log")
    fmt.Println("대용량 파일 처리 예제")
}

이렇게 하면 기가바이트 단위의 로그 파일도 메모리 부담 없이 처리할 수 있어! 스캐너로 한 줄씩 읽으면서 정규표현식 매칭하는 거지ㅋㅋ

🎓 실무 활용 사례 모음

이제 실제로 많이 쓰이는 패턴들을 모아봤어! 복붙해서 바로 쓸 수 있게 정리했으니까 북마크 ㄱㄱ 📌

1. 데이터 검증 패턴

package main

import (
    "fmt"
    "regexp"
)

// 검증 함수들
var (
    // 이메일 (RFC 5322 간소화 버전)
    EmailRegex = regexp.MustCompile(`^[a-zA-Z0-9.!#$%&'*+/=?^_` + "`" + `{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$`)
    
    // 한국 휴대폰 번호
    PhoneRegex = regexp.MustCompile(`^01[0-9]-?\d{3,4}-?\d{4}$`)
    
    // URL (http, https)
    URLRegex = regexp.MustCompile(`^https?://[^\s/$.?#].[^\s]*$`)
    
    // IPv4 주소
    IPv4Regex = regexp.MustCompile(`^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$`)
    
    // 신용카드 번호 (기본 형식)
    CreditCardRegex = regexp.MustCompile(`^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})$`)
    
    // 비밀번호 (8자 이상, 영문+숫자+특수문자)
    PasswordRegex = regexp.MustCompile(`^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$`)
    
    // 한국 우편번호 (5자리)
    PostalCodeRegex = regexp.MustCompile(`^\d{5}$`)
    
    // 주민등록번호 (앞자리-뒷자리)
    SSNRegex = regexp.MustCompile(`^\d{6}-[1-4]\d{6}$`)
)

func main() {
    fmt.Println("=== 데이터 검증 테스트 ===\n")
    
    // 이메일 검증
    emails := []string{
        "test@example.com",
        "user.name+tag@example.co.kr",
        "invalid@",
        "@invalid.com",
    }
    
    fmt.Println("이메일 검증:")
    for _, email := range emails {
        result := "❌"
        if EmailRegex.MatchString(email) {
            result = "✅"
        }
        fmt.Printf("  %s %s\n", result, email)
    }
    
    // 전화번호 검증
    phones := []string{
        "010-1234-5678",
        "01012345678",
        "011-123-4567",
        "02-1234-5678", // 일반 전화
    }
    
    fmt.Println("\n휴대폰 번호 검증:")
    for _, phone := range phones {
        result := "❌"
        if PhoneRegex.MatchString(phone) {
            result = "✅"
        }
        fmt.Printf("  %s %s\n", result, phone)
    }
    
    // URL 검증
    urls := []string{
        "https://www.example.com",
        "http://localhost:8080/api",
        "ftp://files.com", // ftp는 매칭 안됨
        "not-a-url",
    }
    
    fmt.Println("\nURL 검증:")
    for _, url := range urls {
        result := "❌"
        if URLRegex.MatchString(url) {
            result = "✅"
        }
        fmt.Printf("  %s %s\n", result, url)
    }
}

2. 텍스트 추출 패턴

package main

import (
    "fmt"
    "regexp"
)

type SocialTextParser struct {
    HashtagRegex  *regexp.Regexp
    MentionRegex  *regexp.Regexp
    URLRegex      *regexp.Regexp
    EmojiRegex    *regexp.Regexp
}

func NewSocialTextParser() *SocialTextParser {
    return &SocialTextParser{
        // 해시태그: #으로 시작, 한글/영문/숫자
        HashtagRegex: regexp.MustCompile(`#[가-힣a-zA-Z0-9_]+`),
        
        // 멘션: @로 시작, 영문/숫자/언더스코어
        MentionRegex: regexp.MustCompile(`@[a-zA-Z0-9_]+`),
        
        // URL
        URLRegex: regexp.MustCompile(`https?://[^\s]+`),
        
        // 이모지 (기본 범위)
        EmojiRegex: regexp.MustCompile(`[\x{1F600}-\x{1F64F}]|[\x{1F300}-\x{1F5FF}]|[\x{1F680}-\x{1F6FF}]|[\x{2600}-\x{26FF}]`),
    }
}

func (p *SocialTextParser) Parse(text string) map[string][]string {
    return map[string][]string{
        "hashtags": p.HashtagRegex.FindAllString(text, -1),
        "mentions": p.MentionRegex.FindAllString(text, -1),
        "urls":     p.URLRegex.FindAllString(text, -1),
    }
}

func main() {
    parser := NewSocialTextParser()
    
    text := `
    오늘 #재능넷 에서 #Go언어 강의 들었는데 대박! 🔥
    @instructor님 감사합니다 😊
    자세한 내용: https://www.jaenung.net/courses/golang
    #프로그래밍 #개발자 #코딩
    `
    
    result := parser.Parse(text)
    
    fmt.Println("=== SNS 텍스트 파싱 결과 ===\n")
    
    fmt.Println("해시태그:")
    for _, tag := range result["hashtags"] {
        fmt.Println("  -", tag)
    }
    
    fmt.Println("\n멘션:")
    for _, mention := range result["mentions"] {
        fmt.Println("  -", mention)
    }
    
    fmt.Println("\nURL:")
    for _, url := range result["urls"] {
        fmt.Println("  -", url)
    }
}

// 출력:
// === SNS 텍스트 파싱 결과 ===
//
// 해시태그:
//   - #재능넷
//   - #Go언어
//   - #프로그래밍
//   - #개발자
//   - #코딩
//
// 멘션:
//   - @instructor
//
// URL:
//   - https://www.jaenung.net/courses/golang

이런 파서는 SNS 플랫폼이나 커뮤니티 사이트에서 진짜 많이 써! 해시태그로 검색 기능 만들거나, 멘션으로 알림 보내거나, URL 자동 링크 처리할 때 필수야 🎯

3. 코드 분석 패턴

package main

import (
    "fmt"
    "regexp"
)

type CodeAnalyzer struct {
    FunctionRegex *regexp.Regexp
    ImportRegex   *regexp.Regexp
    CommentRegex  *regexp.Regexp
    TODORegex     *regexp.Regexp
}

func NewCodeAnalyzer() *CodeAnalyzer {
    return &CodeAnalyzer{
        // 함수 선언: func 함수명(
        FunctionRegex: regexp.MustCompile(`func\s+(\w+)\s*\(`),
        
        // import 문
        ImportRegex: regexp.MustCompile(`import\s+"([^"]+)"`),
        
        // 주석 (// 또는 /* */)
        CommentRegex: regexp.MustCompile(`//.*|/\*[\s\S]*?\*/`),
        
        // TODO 주석
        TODORegex: regexp.MustCompile(`//\s*TODO:?\s*(.+)`),
    }
}

func (a *CodeAnalyzer) AnalyzeCode(code string) {
    fmt.Println("=== 코드 분석 결과 ===\n")
    
    // 함수 찾기
    functions := a.FunctionRegex.FindAllStringSubmatch(code, -1)
    fmt.Printf("함수 개수: %d\n", len(functions))
    for _, fn := range functions {
        fmt.Printf("  - %s()\n", fn[1])
    }
    
    // import 찾기
    imports := a.ImportRegex.FindAllStringSubmatch(code, -1)
    fmt.Printf("\nimport 개수: %d\n", len(imports))
    for _, imp := range imports {
        fmt.Printf("  - %s\n", imp[1])
    }
    
    // TODO 찾기
    todos := a.TODORegex.FindAllStringSubmatch(code, -1)
    if len(todos) > 0 {
        fmt.Printf("\nTODO 항목: %d개\n", len(todos))
        for i, todo := range todos {
            fmt.Printf("  %d. %s\n", i+1, todo[1])
        }
    }
}

func main() {
    analyzer := NewCodeAnalyzer()
    
    sampleCode := `
package main

import "fmt"
import "regexp"

// TODO: 에러 처리 개선 필요
func processData(data string) error {
    // 데이터 처리 로직
    return nil
}

// TODO: 테스트 코드 작성
func validateInput(input string) bool {
    return true
}

func main() {
    fmt.Println("Hello, World!")
}
`
    
    analyzer.AnalyzeCode(sampleCode)
}

// 출력:
// === 코드 분석 결과 ===
//
// 함수 개수: 3
//   - processData()
//   - validateInput()
//   - main()
//
// import 개수: 2
//   - fmt
//   - regexp
//
// TODO 항목: 2개
//   1. 에러 처리 개선 필요
//   2. 테스트 코드 작성

이런 코드 분석 도구는 정적 분석기나 린터 만들 때 기본이 돼. 코드 리뷰 자동화하거나 프로젝트 통계 내는 데도 유용하지ㅋㅋ

🐛 자주 하는 실수와 해결법

정규표현식 쓰다 보면 다들 비슷한 실수를 해ㅋㅋㅋ 내가 겪었던 것들 위주로 정리해볼게!

실수 1: 이스케이프 처리 안 함

특수문자를 문자 그대로 매칭하고 싶으면 백슬래시로 이스케이프해야 해! Go에서는 백틱(`)으로 raw string을 쓰면 편해.

실수 2: Greedy vs Non-Greedy 혼동

package main

import (
    "fmt"
    "regexp"
)

func main() {
    html := `<div>첫 번째</div><div>두 번째</div>`
    
    // Greedy: 가능한 한 많이 매칭
    greedyPattern := regexp.MustCompile(`<div>.*</div>`)
    fmt.Println("Greedy 결과:")
    fmt.Println(greedyPattern.FindString(html))
    // 출력: <div>첫 번째</div><div>두 번째</div> (전체 매칭!)
    
    // Non-Greedy: 가능한 한 적게 매칭
    nonGreedyPattern := regexp.MustCompile(`<div>.*?</div>`)
    fmt.Println("\nNon-Greedy 결과:")
    fmt.Println(nonGreedyPattern.FindAllString(html, -1))
    // 출력: [<div>첫 번째</div> <div>두 번째</div>] (개별 매칭!)
}

// 출력:
// Greedy 결과:
// <div>첫 번째</div><div>두 번째</div>
//
// Non-Greedy 결과:
// [<div>첫 번째</div> <div>두 번째</div>]

?를 수량자 뒤에 붙이면 non-greedy가 돼! *?, +?, {n,}? 이런 식으로 쓸 수 있어.

실수 3: 멀티라인 텍스트 처리

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := `첫 번째 줄
두 번째 줄
세 번째 줄`
    
    // 기본 모드: ^ 와 $ 는 전체 문자열의 시작/끝
    pattern1 := regexp.MustCompile(`^.+$`)
    fmt.Println("기본 모드:")
    fmt.Println(pattern1.FindString(text))
    // 출력: 첫 번째 줄 (첫 줄만)
    
    // 멀티라인 모드: (?m) 플래그 사용
    pattern2 := regexp.MustCompile(`(?m)^.+$`)
    fmt.Println("\n멀티라인 모드:")
    fmt.Println(pattern2.FindAllString(text, -1))
    // 출력: [첫 번째 줄 두 번째 줄 세 번째 줄]
    
    // . 이 개행 문자도 매칭하게: (?s) 플래그
    pattern3 := regexp.MustCompile(`(?s)^.+$`)
    fmt.Println("\nDotAll 모드:")
    fmt.Println(pattern3.FindString(text))
    // 출력: 전체 텍스트 (개행 포함)
}

// 출력:
// 기본 모드:
// 첫 번째 줄
//
// 멀티라인 모드:
// [첫 번째 줄 두 번째 줄 세 번째 줄]
//
// DotAll 모드:
// 첫 번째 줄
// 두 번째 줄
// 세 번째 줄

실수 4: nil 체크 안 함

package main

import (
    "fmt"
    "regexp"
)

func extractEmail(text string) (string, bool) {
    emailPattern := regexp.MustCompile(`[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`)
    
    match := emailPattern.FindString(text)
    
    // ❌ 나쁜 예: nil 체크 없이 사용
    // return match[0], true // 패닉 발생 가능!
    
    // ✅ 좋은 예: nil 체크
    if match == "" {
        return "", false
    }
    return match, true
}

func extractEmailWithGroups(text string) (string, string, bool) {
    emailPattern := regexp.MustCompile(`([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})`)
    
    matches := emailPattern.FindStringSubmatch(text)
    
    // ✅ 서브매치도 nil 체크 필수
    if matches == nil || len(matches) < 3 {
        return "", "", false
    }
    
    return matches[1], matches[2], true
}

func main() {
    // 이메일 있는 경우
    if email, ok := extractEmail("연락처: test@example.com"); ok {
        fmt.Println("찾은 이메일:", email)
    }
    
    // 이메일 없는 경우
    if _, ok := extractEmail("이메일 없음"); !ok {
        fmt.Println("이메일을 찾을 수 없습니다")
    }
    
    // 그룹 추출
    if username, domain, ok := extractEmailWithGroups("user@domain.com"); ok {
        fmt.Printf("사용자명: %s, 도메인: %s\n", username, domain)
    }
}

// 출력:
// 찾은 이메일: test@example.com
// 이메일을 찾을 수 없습니다
// 사용자명: user, 도메인: domain.com

매칭 결과는 항상 nil일 수 있다는 걸 기억해! 특히 FindStringSubmatch 같은 건 슬라이스 길이도 체크해야 안전해 🛡️

🎯 정리하며

와... 여기까지 읽었으면 진짜 대단한 거야ㅋㅋㅋ 정규표현식이랑 Go의 regexp 패키지에 대해 거의 다 다뤘어! 마지막으로 핵심만 정리해볼게 📝

정규표현식은 처음엔 어렵게 느껴지지만, 익숙해지면 진짜 강력한 무기가 돼. 특히 텍스트 처리, 데이터 검증, 로그 분석 같은 작업에서는 필수 스킬이지!

재능넷 같은 플랫폼에서도 사용자 입력 검증, 검색 기능, 텍스트 파싱 등 다양한 곳에 정규표현식이 쓰여. 실무에서 바로 활용할 수 있는 내용들이니까 북마크해두고 필요할 때마다 참고하면 좋을 거야! 💪

Go 언어로 개발하면서 정규표현식 잘 활용하면 코드 품질이 확 올라가. 특히 문자열 처리가 많은 백엔드 개발에서는 필수 중의 필수지! 화이팅 🔥