package main

import (
	"fmt"
	"regexp"
)

func main() {
	// 編譯一個簡單的正則表達式
	re, err := regexp.Compile(`hello`)
	if err != nil {
		fmt.Printf("編譯正則表達式失敗: %v\n", err)
		return
	}
	fmt.Println("正則表達式編譯成功")
	
	// 使用編譯后的正則表達式
	fmt.Println(re.MatchString("hello world")) // 輸出: true
}

package main

import (
	"fmt"
	"regexp"
)

// 包級變量，使用MustCompile初始化
var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)

func main() {
	email := "test@example.com"
	if emailRegex.MatchString(email) {
		fmt.Printf("%s 是有效的郵箱地址\n", email)
	} else {
		fmt.Printf("%s 是無效的郵箱地址\n", email)
	}
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`) // 匹配一個或多個數(shù)字
	
	fmt.Println(re.MatchString("123"))    // true
	fmt.Println(re.MatchString("abc"))    // false
	fmt.Println(re.MatchString("abc123")) // true，因為包含數(shù)字
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`go`)
	data := []byte("golang")
	fmt.Println(re.Match(data)) // true
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`) // 匹配數(shù)字
	s := "abc123def456ghi"
	
	fmt.Println(re.FindString(s)) // 輸出: 123
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	s := "abc123def456ghi"
	
	indices := re.FindStringIndex(s)
	if indices != nil {
		fmt.Printf("匹配位置: %d-%d\n", indices[0], indices[1]) // 3-6
		fmt.Println("匹配內(nèi)容:", s[indices[0]:indices[1]])     // 123
	}
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// 匹配日期，包含三個捕獲組：年、月、日
	re := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
	s := "今天是2023-10-05，昨天是2023-10-04"
	
	// 查找第一個匹配
	submatches := re.FindStringSubmatch(s)
	if submatches != nil {
		fmt.Println("完整匹配:", submatches[0]) // 2023-10-05
		fmt.Println("年:", submatches[1])      // 2023
		fmt.Println("月:", submatches[2])      // 10
		fmt.Println("日:", submatches[3])      // 05
	}
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
	s := "今天是2023-10-05，昨天是2023-10-04"
	
	indices := re.FindStringSubmatchIndex(s)
	if indices != nil {
		fmt.Println("索引:", indices) // 輸出: [3 13 3 7 8 10 11 13]
        fmt.Println("完整匹配:", s[indices[0]:indices[1]]) // 2023-10-05
		fmt.Println("年:", s[indices[2]:indices[3]])      // 2023
		fmt.Println("月:", s[indices[4]:indices[5]])      // 10
		fmt.Println("日:", s[indices[6]:indices[7]])      // 05
	}
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	s := "abc123def456ghi789"
	
	// 返回所有匹配項
	matches := re.FindAllString(s, -1)
	fmt.Println("所有匹配:", matches) // 輸出: [123 456 789]
	
	// 只返回前兩個匹配項
	matches = re.FindAllString(s, 2)
	fmt.Println("前兩個匹配:", matches) // 輸出: [123 456]
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	s := "abc123def456ghi789"
	
	indices := re.FindAllStringIndex(s, -1)
	for i, idx := range indices {
		fmt.Printf("匹配 %d: 位置 %d-%d, 內(nèi)容 %s\n", 
			i+1, idx[0], idx[1], s[idx[0]:idx[1]])
	}
	// 輸出:
	// 匹配 1: 位置 3-6, 內(nèi)容 123
	// 匹配 2: 位置 9-12, 內(nèi)容 456
	// 匹配 3: 位置 15-18, 內(nèi)容 789
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(\w+)-(\d+)`)
	s := "item1-123 item2-456 item3-789"
	
	matches := re.FindAllStringSubmatch(s, -1)
	for i, match := range matches {
		fmt.Printf("匹配 %d: 完整=%s, 組1=%s, 組2=%s\n",
			i+1, match[0], match[1], match[2])
	}
	// 輸出:
	// 匹配 1: 完整=item1-123, 組1=item1, 組2=123
	// 匹配 2: 完整=item2-456, 組1=item2, 組2=456
	// 匹配 3: 完整=item3-789, 組1=item3, 組2=789
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	src := "hello123world456"
	
	// 替換所有數(shù)字為X
	result := re.ReplaceAllString(src, "X")
	fmt.Println("替換結(jié)果:", result) // 輸出: helloXworldX
}

package main

import (
	"fmt"
	"regexp"
	"strconv"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	src := "hello123world456"
	
	// 將每個數(shù)字部分轉(zhuǎn)換為其長度
	result := re.ReplaceAllStringFunc(src, func(match string) string {
		return strconv.Itoa(len(match))
	})
	
	fmt.Println("替換結(jié)果:", result) // 輸出: hello3world3
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`a.b`)
	src := "acb aab abb"
	
	// 使用$符號作為替換文本
	result := re.ReplaceAllLiteralString(src, "$1")
	fmt.Println("替換結(jié)果:", result) // 輸出: $1 $1 $1
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`[,\s]+`) // 匹配逗號或空白字符
	s := "hello, world  golang,java"
	
	parts := re.Split(s, -1)
	fmt.Println("分割結(jié)果:", parts) // 輸出: [hello world golang java]
}

package main

import (
	"fmt"
	"regexp"
)

// 驗證電子郵件地址的正則表達式
// 該模式匹配大多數(shù)常見的有效郵箱格式
var emailRegex = regexp.MustCompile(`^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,}$`)

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

func main() {
	emails := []string{
		"test@example.com",
		"user.name+tag@domain.co.uk",
		"invalid.email",
		"@missing_username.com",
		"user@domain",
		"user@domain..com",
	}
	
	for _, email := range emails {
		if isValidEmail(email) {
			fmt.Printf("%-25s 是有效的郵箱地址\n", email)
		} else {
			fmt.Printf("%-25s 是無效的郵箱地址\n", email)
		}
	}
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	url := "https://example.com/search?query=golang&page=2&limit=10"
	
	// 匹配查詢參數(shù)的正則表達式
	re := regexp.MustCompile(`([^?&=]+)=([^&]+)`)
	
	// 查找所有匹配的參數(shù)
	matches := re.FindAllStringSubmatch(url, -1)
	
	// 打印提取的參數(shù)
	fmt.Println("從URL中提取的參數(shù):")
	for _, match := range matches {
		fmt.Printf("%-10s = %s\n", match[1], match[2])
	}
}

package main

import (
	"fmt"
	"regexp"
)

func formatPhoneNumber(phone string) string {
	// 移除所有非數(shù)字字符
	re := regexp.MustCompile(`\D`)
	digits := re.ReplaceAllString(phone, "")
	
	// 檢查是否為有效的11位中國手機號
	if len(digits) == 11 {
		return fmt.Sprintf("%s-%s-%s", digits[0:3], digits[3:7], digits[7:11])
	}
	
	// 其他情況返回原始數(shù)字
	return digits
}

func main() {
	phones := []string{
		"13800138000",
		"(139)00139000",
		"137-0013-7000",
		"136 0013 6000",
		"123456", // 無效號碼
	}
	
	for _, phone := range phones {
		fmt.Printf("原號碼: %-15s 格式化后: %s\n", phone, formatPhoneNumber(phone))
	}
}

package main

import (
	"fmt"
	"io/ioutil"
	"regexp"
	"strings"
)

func countLines(code string) int {
	// 移除單行注釋
	reSingleLineComment := regexp.MustCompile(`//.*$`)
	code = reSingleLineComment.ReplaceAllString(code, "")
	
	// 移除多行注釋
	reMultiLineComment := regexp.MustCompile(`/\*.*?\*/`)
	code = reMultiLineComment.ReplaceAllString(code, "")
	
	// 分割成行
	lines := strings.Split(code, "\n")
	
	// 統(tǒng)計非空行
	count := 0
	for _, line := range lines {
		if strings.TrimSpace(line) != "" {
			count++
		}
	}
	
	return count
}

func main() {
	// 示例Go代碼
	code := `package main

import (
	"fmt"
)

func main() {
	// 這是一個注釋
	fmt.Println("Hello, World!") // 打印消息
}
`
	
	lineCount := countLines(code)
	fmt.Printf("代碼有效行數(shù): %d\n", lineCount)
}

package main

import (
	"fmt"
	"regexp"
)

func extractLinks(html string) []string {
	// 匹配<a>標(biāo)簽中的href屬性
	re := regexp.MustCompile(`<a\s+(?:[^>]*?\s+)?href="([^" rel="external nofollow" ]*)"`)
	
	// 查找所有匹配項
	matches := re.FindAllStringSubmatch(html, -1)
	
	// 提取鏈接
	links := make([]string, 0, len(matches))
	for _, match := range matches {
		links = append(links, match[1])
	}
	
	return links
}

func main() {
	html := `
	<html>
	<body>
		<a  rel="external nofollow" >Google</a>
		<a  rel="external nofollow"  class="link">Example</a>
		<a href='#section'>Section</a>
	</body>
	</html>
	`
	
	links := extractLinks(html)
	fmt.Println("提取的鏈接:")
	for _, link := range links {
		fmt.Println(link)
	}
}

for _, text := range texts {
	re, _ := regexp.Compile(`\d+`) // 每次循環(huán)都編譯
	if re.MatchString(text) {
		// 處理匹配
	}
}

var numberRegex = regexp.MustCompile(`\d+`) // 包級別變量，預(yù)編譯一次

func processTexts(texts []string) {
	for _, text := range texts {
		if numberRegex.MatchString(text) {
			// 處理匹配
		}
	}
}

re := regexp.MustCompile(`<.*>`) // 貪婪匹配，可能導(dǎo)致大量回溯

re := regexp.MustCompile(`<[^>]*>`) // 非貪婪匹配，更高效

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// 假設(shè)這是一個非常大的文本
	largeText := "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6"
	
	re := regexp.MustCompile(`\d`)
	
	// 使用FindReaderIndex處理大文本
	matches := 0
	for loc := re.FindReaderIndex(strings.NewReader(largeText)); loc != nil; {
		matches++
		// 處理匹配位置loc
		// 繼續(xù)從下一個位置查找
		loc = re.FindReaderIndex(strings.NewReader(largeText[loc[1]:]))
	}
	
	fmt.Printf("找到 %d 個匹配項\n", matches)
}

// 驗證IP地址
var ipRegex = 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]?)$`)

// 驗證URL
var urlRegex = regexp.MustCompile(`^(https?|ftp)://[^\s/$.?#].[^\s]*$`)

// 驗證中國手機號
var phoneRegex = regexp.MustCompile(`^1[3-9]\d{9}$`)

// 驗證日期（YYYY-MM-DD格式）
var dateRegex = regexp.MustCompile(`^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$`)

// 驗證密碼強度（至少8位，包含大小寫字母和數(shù)字）
var passwordRegex = regexp.MustCompile(`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$`)

// 提取HTML標(biāo)簽
var htmlTagRegex = regexp.MustCompile(`<[^>]+>`)

// 提取郵箱地址
var emailExtractRegex = regexp.MustCompile(`[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}`)

// 提取域名
var domainRegex = regexp.MustCompile(`(?i)[a-z0-9][a-z0-9-]{0,61}[a-z0-9](?:\.[a-z]{2,})+`)

// 提取圖片URL
var imageUrlRegex = regexp.MustCompile(`(?i)\b(https?://[^>\s]+?\.(jpg|jpeg|png|gif|bmp))\b`)

// 移除HTML標(biāo)簽
func stripHtmlTags(html string) string {
	re := regexp.MustCompile(`<[^>]*>`)
	return re.ReplaceAllString(html, "")
}

// 移除連續(xù)空格
func removeExtraSpaces(text string) string {
	re := regexp.MustCompile(`\s+`)
	return re.ReplaceAllString(text, " ")
}

// 轉(zhuǎn)換駝峰命名為蛇形命名
func camelToSnake(s string) string {
	re := regexp.MustCompile(`([a-z0-9])([A-Z])`)
	return re.ReplaceAllString(s, "${1}_${2}")
}

// 轉(zhuǎn)換蛇形命名為駝峰命名
func snakeToCamel(s string) string {
	re := regexp.MustCompile(`_([a-z])`)
	return re.ReplaceAllStringFunc(s, func(match string) string {
		return strings.ToUpper(match[1:])
	})
}