Kotlin
regex

Idiomer för Regex-matchning i uttryck

Använda oföränderliga lokalbefolkningen:

Använder mindre horisontellt utrymme men mer vertikalt utrymme än "anonyma tillfälliga" -mallen. Föredraget över mallen "anonyma tillfälliga" om uttrycket when är i en slinga - i så fall bör regex-definitioner placeras utanför slingan.

import kotlin.text.regex

var string = /* some string */

val regex1 = Regex( /* pattern */ )
val regex2 = Regex( /* pattern */ )
/* etc */

when {
    regex1.matches(string) -> /* do stuff */
    regex2.matches(string) -> /* do stuff */
    /* etc */
}

Använda anonyma tillfälliga:

Använder mindre vertikalt utrymme men mer horisontellt utrymme än "immutable locals" -mallen. Bör inte användas om when uttrycket är i en slinga.

import kotlin.text.regex

var string = /* some string */

when {  
    Regex( /* pattern */ ).matches(string) -> /* do stuff */
    Regex( /* pattern */ ).matches(string) -> /* do stuff */
    /* etc */
}

Använda besökarmönstret:

Har fördelen av att noggrant efterlikna "argument-ful" when syntax. Detta är fördelaktigt eftersom det tydligare indikerar argumentet för when uttrycket och också utesluter vissa programmerarens misstag som kan uppstå från att behöva upprepa when argumentet i varje whenEntry . Antingen "immutable locals" eller "anonym temporaries" -mallen kan användas med denna implementering av besökarmönstret.

import kotlin.text.regex

var string = /* some string */

when (RegexWhenArgument(string)) {
    Regex( /* pattern */ ) -> /* do stuff */
    Regex( /* pattern */ ) -> /* do stuff */
    /* etc */
}

Och den minimala definitionen av omslagsklassen för argumentet when uttrycket:

class RegexWhenArgument (val whenArgument: CharSequence) {
    operator fun equals(whenEntry: Regex) = whenEntry.matches(whenArgument)
    override operator fun equals(whenEntry: Any?) = (whenArgument == whenEntry)
}

Introduktion till reguljära uttryck i Kotlin

Det här inlägget visar hur man använder de flesta funktionerna i Regex klassen, arbetar med null på ett säkert sätt relaterat till Regex funktionerna och hur råa strängar gör det lättare att skriva och läsa regex-mönster.

RegEx-klassen

För att arbeta med vanliga uttryck i Kotlin, måste du använda klassen Regex(pattern: String) och åberopa funktioner som att find(..) eller replace(..) för det regex-objektet.

Ett exempel på hur du använder Regex klassen som returnerar sant om input innehåller c eller d:

val regex = Regex(pattern = "c|d")
val matched = regex.containsMatchIn(input = "abc")    // matched: true

Det viktigaste att förstå med alla Regex funktioner är att resultatet baseras på att matcha regex- pattern och input . Vissa av funktionerna kräver en fullständig matchning, medan resten endast kräver en partiell matchning. Funktionen containsMatchIn(..) används i exemplet kräver en partiell matchning och förklaras senare i det här inlägget.

Noll säkerhet med regelbundna uttryck

Både find(..) och matchEntire(..) kommer att returnera ett MatchResult? objekt. ? karaktär efter MatchResult är nödvändigt för att Kotlin ska hantera noll på ett säkert sätt .

Ett exempel som visar hur Kotlin hanterar noll på ett säkert sätt från en Regex funktion när funktionen Regex find(..) returnerar null:

val matchResult = 
    Regex("c|d").find("efg")           // matchResult: null
val a = matchResult?.value             // a: null
val b = matchResult?.value.orEmpty()   // b: ""
a?.toUpperCase()                       // Still needs question mark. => null    
b.toUpperCase()                        // Accesses the function directly. => ""

Med orEmpty() kan b inte vara noll och ? tecken är onödigt när du ringer funktioner på b .

Om du inte bryr dig om denna säkra hantering av nollvärden låter Kotlin arbeta med nollvärden som i Java med !! tecken:

a!!.toUpperCase()                      // => KotlinNullPointerException

Rå strängar i regexmönster

Kotlin tillhandahåller en förbättring jämfört med Java med en rå sträng som gör det möjligt att skriva rena regex-mönster utan dubbla backstryk, som är nödvändiga med en Java-sträng. En rå sträng representeras med en tredubbla citat:

"""\d{3}-\d{3}-\d{4}""" // raw Kotlin string
"\\d{3}-\\d{3}-\\d{4}"  // standard Java string

hitta (input: CharSequence, startIndex: Int): MatchResult?

input matchas mot pattern i Regex objektet. Det ger ett Matchresult? objekt med den första matchade texten efter startIndex , eller null om mönstret inte matchar input . Resultatsträngen hämtas från MatchResult? objektets value . startIndex parametern är valfri med standardvärdet 0.

Så här extraherar du det första giltiga telefonnumret från en sträng med kontaktinformation:

val phoneNumber :String? = Regex(pattern = """\d{3}-\d{3}-\d{4}""")
    .find(input = "phone: 123-456-7890, e..")?.value // phoneNumber: 123-456-7890

Med inget giltigt telefonnummer i input kommer variabeln phoneNumber att vara null .

findAll (input: CharSequence, startIndex: Int): Sekvens

Återgår alla matcher från input som matchar regex pattern .

Så här skriver du ut alla siffror separerade med mellanslag, från en text med bokstäver och siffror:

val matchedResults = Regex(pattern = """\d+""").findAll(input = "ab12cd34ef")
val result = StringBuilder()
for (matchedText in matchedResults) {
    result.append(matchedText.value + " ")
}

println(result) // => 12 34

matchedResults är en sekvens med MatchResult objekt. Med en input utan siffror kommer findAll(..) att returnera en tom sekvens.

matchEntire (input: CharSequence): MatchResult?

Om alla tecken i input matchar regexmönstret pattern en sträng som är lika med input . Annars kommer null att returneras.

Returnerar ingångssträngen om hela inmatningssträngen är ett nummer:

val a = Regex("""\d+""").matchEntire("100")?.value             // a: 100
val b = Regex("""\d+""").matchEntire("100 dollars")?.value     // b: null

matchningar (input: CharSequence): Boolean

Returnerar sant om hela inmatningssträngen matchar regexmönstret. Falskt annars.

Testar om två strängar bara innehåller siffror:

val regex = Regex(pattern = """\d+""")
regex.matches(input = "50")             // => true
regex.matches(input = "50 dollars")     // => false

innehållerMatchIn (input: CharSequence): Boolean

Returnerar sant om en del av inmatningssträngen matchar regexmönstret. Falskt annars.

Testa om två strängar innehåller minst en siffra:

Regex("""\d+""").containsMatchIn("50 dollars")       // => true
Regex("""\d+""").containsMatchIn("Fifty dollars")    // => false

split (input: CharSequence, limit: Int): Lista

Returnerar en ny lista utan alla regex-matchningar.

För att returnera listor utan siffror:

val a = Regex("""\d+""").split("ab12cd34ef")     // a: [ab, cd, ef]
val b = Regex("""\d+""").split("This is a test") // b: [This is a test]

Det finns ett element i listan för varje delning. Den första input har tre siffror. Det resulterar i en lista med tre element.

byt ut (input: CharSequence, ersättning: String): String

Ersätter alla matcher i regex pattern i input med ersättningssträngen.

Så här ersätter du alla siffror i en sträng med en x:

val result = Regex("""\d+""").replace("ab12cd34ef", "x") // result: abxcdxef