Kotlin版正则表达式及其常见使用代码举例

.       // 匹配任意单个字符（除换行符）
^       // 匹配字符串开始
$       // 匹配字符串结束
*       // 匹配前一个元素0次或多次
+       // 匹配前一个元素1次或多次
?       // 匹配前一个元素0次或1次
{n}     // 精确匹配n次
{n,}    // 至少匹配n次
{n,m}   // 匹配n到m次
|       // 或运算符
()      // 分组
[]      // 字符集
\d      // 数字，等价于[0-9]
\D      // 非数字
\w      // 单词字符，等价于[a-zA-Z0-9_]
\W      // 非单词字符
\s      // 空白字符
\S      // 非空白字符

[abc]      // 匹配a、b或c
[^abc]     // 匹配除a、b、c外的字符
[a-z]      // 匹配a到z的小写字母
[a-zA-Z]   // 匹配所有字母
[0-9]      // 匹配数字

// 方式1：使用构造函数
val regex1 = Regex("""\d+""")  // 原始字符串，推荐

// 方式2：使用字符串扩展函数
val regex2 = "\\d+".toRegex()

// 方式3：使用编译选项
val regex3 = Regex("pattern", RegexOption.IGNORE_CASE)

val emailRegex = """^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$""".toRegex()

fun validateEmail(email: String): Boolean {
    return email.matches(emailRegex)
}

// 使用
println(validateEmail("test@example.com"))  // true
println(validateEmail("invalid-email"))     // false

fun findNumbers(text: String): List<String> {
    val numberRegex = """\d+""".toRegex()
    return numberRegex.findAll(text).map { it.value }.toList()
}

// 使用
val text = "订单号：12345，金额：678元"
println(findNumbers(text))  // [12345, 678]

fun extractDateInfo(dateStr: String): Triple<String, String, String>? {
    val regex = """(\d{4})-(\d{2})-(\d{2})""".toRegex()
    val match = regex.find(dateStr) ?: return null
    
    // group(0)是整个匹配，group(1)开始是捕获组
    return Triple(
        match.groupValues[1],  // 年
        match.groupValues[2],  // 月
        match.groupValues[3]   // 日
    )
}

// 使用
val result = extractDateInfo("今天日期是2024-01-15")
println(result)  // (2024, 01, 15)

fun maskPhoneNumber(phone: String): String {
    val regex = """(\d{3})\d{4}(\d{4})""".toRegex()
    return regex.replace(phone, "$1****$2")  // $1和$2引用捕获组
}

// 使用
println(maskPhoneNumber("13812345678"))  // 138****5678

fun splitByPunctuation(text: String): List<String> {
    val regex = """[,.;!?]""".toRegex()
    return text.split(regex)
}

// 使用
val words = splitByPunctuation("Hello,world!How are you?")
println(words)  // [Hello, world, How are you]

fun containsUrl(text: String): Boolean {
    val urlRegex = """https?://[^\s]+""".toRegex()
    return urlRegex.containsMatchIn(text)
}

// 使用
println(containsUrl("访问 https://example.com 了解更多"))  // true

fun parseLogLine(log: String): Map<String, String> {
    val regex = """(?<timestamp>\d{4}-\d{2}-\d{2}) (?<level>\w+): (?<message>.+)""".toRegex()
    val match = regex.find(log) ?: return emptyMap()
    
    return match.groups as? Map<String, String> ?: emptyMap()
}

// 使用
val log = "2024-01-15 ERROR: 数据库连接失败"
val parsed = parseLogLine(log)
println(parsed["timestamp"])  // 2024-01-15

val multiLineRegex = """^start.*end$""".toRegex(
    setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE)
)

val text = """
    start first END
    middle
    start second End
""".trimIndent()

println(multiLineRegex.findAll(text).count())  // 2

fun findWholeWord(text: String, word: String): List<String> {
    // \b 表示单词边界
    val regex = """\b$word\b""".toRegex(RegexOption.IGNORE_CASE)
    return regex.findAll(text).map { it.value }.toList()
}

// 使用
val result = findWholeWord("cat catalog scatter", "cat")
println(result)  // [cat] (不会匹配到catalog和scatter中的cat)

fun extractHtmlTag(html: String, tagName: String): String? {
    // *? 表示非贪婪匹配，尽可能少地匹配字符
    val regex = """<$tagName>.*?</$tagName>""".toRegex()
    return regex.find(html)?.value
}

// 使用
val html = "<div>内容1</div><div>内容2</div>"
println(extractHtmlTag(html, "div"))  // <div>内容1</div>

object Validator {
    // 手机号（中国）
    private val phoneRegex = """^1[3-9]\d{9}$""".toRegex()
    
    // 邮箱
    private val emailRegex = """^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$""".toRegex()
    
    // 身份证号（18位）
    private val idCardRegex = """^\d{17}[\dXx]$""".toRegex()
    
    // URL
    private val urlRegex = """^https?://[^\s/$.?#].[^\s]*$""".toRegex()
    
    // IPv4地址
    private val ipv4Regex = """^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$""".toRegex()
    
    fun isValidPhone(phone: String) = phone.matches(phoneRegex)
    fun isValidEmail(email: String) = email.matches(emailRegex)
    fun isValidIdCard(idCard: String) = idCard.matches(idCardRegex)
    fun isValidUrl(url: String) = url.matches(urlRegex)
    fun isValidIpv4(ip: String): Boolean {
        if (!ip.matches(ipv4Regex)) return false
        return ip.split(".").all { it.toInt() in 0..255 }
    }
}

class SensitiveFilter(private val sensitiveWords: List<String>) {
    private val regex by lazy {
        // 构建或模式，如：\b(词1|词2|词3)\b
        val pattern = sensitiveWords.joinToString("|") { Regex.escape(it) }
        """\b($pattern)\b""".toRegex(RegexOption.IGNORE_CASE)
    }
    
    fun filter(text: String, replacement: String = "***"): String {
        return regex.replace(text, replacement)
    }
    
    fun hasSensitiveWord(text: String): Boolean {
        return regex.containsMatchIn(text)
    }
}

// 使用
val filter = SensitiveFilter(listOf("广告", "诈骗", "违规"))
val text = "这是一条广告信息，不要信"
println(filter.filter(text))  // 这是一条***信息，不要信

data class LogEntry(
    val timestamp: String,
    val level: String,
    val thread: String,
    val className: String,
    val message: String
)

fun parseLog(log: String): LogEntry? {
    val regex = """(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\s+(\w+)\s+\[([^\]]+)\]\s+([\w.]+)\s+(.+)"""
        .toRegex()
    
    val match = regex.find(log) ?: return null
    
    return LogEntry(
        timestamp = match.groupValues[1],
        level = match.groupValues[2],
        thread = match.groupValues[3],
        className = match.groupValues[4],
        message = match.groupValues[5]
    )
}