Kotlin
Regex

Idiome für Regex-Abgleich in When-Ausdruck

Verwenden unveränderlicher Einheimischer:

Verwendet weniger horizontalen Raum, aber mehr vertikalen Raum als die Vorlage "Anonyme temporäre". Vorzuziehen gegenüber der Vorlage "anonyme temporäre", wenn sich der when Ausdruck in einer Schleife befindet. In diesem Fall sollten Regex-Definitionen außerhalb der Schleife platziert werden.

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 */
}

Verwendung anonymer Provisorien:

Verwendet weniger vertikalen Raum, aber mehr horizontalen Raum als die Vorlage "unveränderliche Einheimische". Sollte nicht verwendet werden, when Ausdruck in einer Schleife befindet.

import kotlin.text.regex

var string = /* some string */

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

Verwenden des Besuchermusters:

Hat den Vorteil, die "argument-ful" when Syntax genau zu emulieren. Dies ist vorteilhaft, da es klarer das Argument des when Ausdrucks anzeigt und bestimmte Programmiererfehler ausschließt, die daraus whenEntry könnten, dass das when Argument in jedem whenEntry wiederholt werden whenEntry . Bei dieser Implementierung kann entweder das "unveränderliche Einheimische" oder das "anonyme temporäre" Template verwendet werden.

import kotlin.text.regex

var string = /* some string */

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

Und die minimale Definition der Wrapper-Klasse für das Argument " when :

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

Einführung in reguläre Ausdrücke in Kotlin

In diesem Beitrag wird gezeigt, wie die meisten Funktionen in der Regex Klasse verwendet werden, wie mit Nullen gearbeitet wird, die sicher mit den Regex Funktionen zusammenhängen, und wie rohe Zeichenfolgen das Schreiben und Lesen von Regex-Mustern erleichtern.

Die RegEx-Klasse

Um mit regulären Ausdrücken in Kotlin zu arbeiten, müssen Sie die Klasse Regex(pattern: String) und Funktionen wie find(..) oder replace(..) für dieses Regex-Objekt aufrufen.

Ein Beispiel zur Verwendung der Regex Klasse, die true zurückgibt, wenn die input c oder d enthält:

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

Für alle Regex Funktionen ist es wichtig zu verstehen, dass das Ergebnis auf dem Abgleich des Regex- pattern und der input basiert. Einige Funktionen erfordern eine vollständige Übereinstimmung, während die restlichen Funktionen nur eine teilweise Übereinstimmung erfordern. Die in diesem Beispiel verwendete Funktion containsMatchIn(..) erfordert eine teilweise Übereinstimmung und wird später in diesem Beitrag erläutert.

Null Sicherheit mit regulären Ausdrücken

find(..) und matchEntire(..) MatchResult? ein MatchResult? Objekt. Die ? Ein Zeichen nach MatchResult ist für Kotlin erforderlich, um Null sicher zu behandeln.

Ein Beispiel, das zeigt, wie Kotlin mit einer Regex Funktion sicher mit Null Regex , wenn die find(..) Funktion Null zurückgibt:

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. => ""

Mit der Funktion orEmpty() kann b nicht null sein und das ? Ein Zeichen ist nicht erforderlich, wenn Sie Funktionen über b aufrufen.

Wenn Sie sich nicht für den sicheren Umgang mit Nullwerten interessieren, können Sie mit Kotlin mit Nullwerten wie in Java mit dem !! Zeichen:

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

Raw-Strings in Regex-Mustern

Kotlin bietet eine Verbesserung gegenüber Java mit einem Raw-String , der das Schreiben reiner Regex-Muster ohne doppelte Backslashes ermöglicht, die für einen Java-String erforderlich sind. Eine rohe Zeichenfolge wird mit einem dreifachen Anführungszeichen dargestellt:

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

find (Eingabe: CharSequence, startIndex: Int): MatchResult?

Die input wird mit dem pattern im Regex Objekt abgeglichen. Matchresult? ein Matchresult? Objekt mit dem ersten übereinstimmenden Text nach dem startIndex oder null wenn das Muster nicht mit der input übereinstimmt. Die Ergebniszeichenfolge wird vom MatchResult? abgerufen MatchResult? value Eigenschaft des Objekts. Der Parameter startIndex ist optional mit dem Standardwert 0.

So extrahieren Sie die erste gültige Telefonnummer aus einer Zeichenfolge mit Kontaktdaten:

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

Ohne gültige Telefonnummer in der input ist die Variable phoneNumber null .

findAll (Eingabe: CharSequence, StartIndex: Int): Sequenz

Gibt alle Übereinstimmungen aus der input , die dem Regex- pattern .

So drucken Sie alle mit Leerzeichen getrennten Zahlen aus einem Text mit Buchstaben und Ziffern:

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

println(result) // => 12 34

Die matchedResults Variable ist eine Sequenz mit MatchResult Objekten. Bei einer input ohne Ziffern gibt die findAll(..) Funktion eine leere Sequenz zurück.

matchEntire (Eingabe: CharSequence): MatchResult?

Wenn alle Zeichen in der input dem Regex- pattern , wird eine Zeichenfolge zurückgegeben, die der input . Andernfalls wird null zurückgegeben.

Gibt die Eingabezeichenfolge zurück, wenn die gesamte Eingabezeichenfolge eine Zahl ist:

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

match (Eingabe: CharSequence): Boolean

Gibt "true" zurück, wenn die gesamte Eingabezeichenfolge dem Regex-Muster entspricht. Sonst falsch.

Testet, ob zwei Zeichenfolgen nur Ziffern enthalten:

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

containsMatchIn (Eingabe: CharSequence): Boolean

Gibt "true" zurück, wenn ein Teil der Eingabezeichenfolge dem Regex-Muster entspricht. Sonst falsch.

Testen Sie, ob zwei Zeichenfolgen mindestens eine Ziffer enthalten:

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

split (Eingabe: CharSequence, Limit: Int): Liste

Gibt eine neue Liste ohne Übereinstimmungen mit den regulären Ausdrücken zurück.

Listen ohne Ziffern zurückgeben:

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

Für jeden Split gibt es ein Element in der Liste. Die erste input hat drei Zahlen. Daraus ergibt sich eine Liste mit drei Elementen.

replace (Eingabe: CharSequence, Ersatz: String): String

Ersetzt alle Übereinstimmungen des Regex- pattern in der input durch die Ersetzungszeichenfolge.

So ersetzen Sie alle Ziffern in einer Zeichenfolge durch ein x:

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